Missing /var/log/cron.log on Linux? Here’s Where cron logs are actually stored


July 10th, 2026

If you've tried to troubleshoot a scheduled cron job or task and discovered that /var/log/cron.log doesn't exist, don't panic. Contrary to what used to be the normal for GNU / Linux distributions few years ago and especially before systemd came on scene, this file is not present on every Linux distribution anymore.

The location of cron logs depends on your Linux distribution, the logging service in use, and how system is configured.

In this guide, we'll explain why /var/log/cron.log may be missing and show you where to find your cron logs instead.

Why is /var/log/cron.log Missing?

There isn't a universal standard for cron logging across Linux distributions.

Some systems write cron events to a dedicated log file, while others store them in the system journal or the general system log. Modern Linux distributions increasingly rely on systemd-journald, which means traditional log files may not exist at all.

Ubuntu and Debian (deb based distros)

On Ubuntu and Debian, cron messages are typically written to the system log instead of a dedicated cron log.

To search for cron entries, run:

# grep CRON /var/log/syslog

Or use systemd's journal:

# journalctl -u cron

If /var/log/cron.log is missing, this is usually expected behavior.

RHEL, CentOS 7 and Similar Distributions

Red Hat Enterprise Linux and CentOS 7 usually maintain a dedicated cron log:

/var/log/cron

View its contents with:

# cat /var/log/cron

Or monitor it in real time:

# tail -f /var/log/cron

Rocky Linux, AlmaLinux, Fedora, and other newer RHEL based (RPM distro) Versions

Newer enterprise distributions commonly use the systemd journal.

To view cron service logs:

# journalctl -u crond

Or filter by the CROND by systlog  identifier:

# journalctl SYSLOG_IDENTIFIER=CROND

Check that the Cron service is running

Before investigating log files, make sure the cron service is active.

On Ubuntu and Debian:

# systemctl status cron

On RHEL-based systems:

# systemctl status crond

If the service isn't running, scheduled jobs won't execute regardless of where logs are stored.

On systems using systemd-journald

Many modern Linux distributions no longer create separate log files for services.

Instead, use the journal:

# journalctl -xe | grep -i cron

Or view only cron-related messages:

# journalctl -u cron

Depending on your distribution, the service may be named cron or crond.

Check Your rsyslog Configuration

If you specifically want a /var/log/cron.log file, verify whether your logging configuration creates one.

Search the configuration:

# grep cron /etc/rsyslog.conf # grep cron /etc/rsyslog.d/*

Some systems include a rule such as:

cron.* /var/log/cron.log

If this rule doesn't exist, cron messages may be redirected to /var/log/syslog or handled entirely by systemd-journald.

After making changes, restart rsyslog:

# systemctl restart rsyslog

Verify That Cron Jobs Are Running

If you're unsure whether cron is functioning, create a simple test job like below.

Add to crontab:

* * * * * echo "cron works $(date)" >> /tmp/cron-test.log

Wait one minute, then check the file:

# cat /tmp/cron-test.log

If new entries appear, cron is working correctly even if a dedicated cron log file is absent.

Summary

The absence of /var/log/cron.log is usually not a problem – it simply reflects how your Linux distribution handles logging.

So to rephrase it:

Modern systemd-based systems: Use journalctl instead of expecting separate log files.

  • Ubuntu/Debian: /var/log/syslog or journalctl -u cron
  • CentOS/RHEL 7: /var/log/cron
  • Rocky Linux, AlmaLinux, Fedora, RHEL 8+: journalctl -u crond

When troubleshooting cron jobs, always verify that the cron service is running as process ( ps -ef | grep cron ), confirm where your distribution stores logs and check cron execution runs / logs fine in /var/log/cron.

No Comments »

« Previous Post

Building a self-healing WordPress Monitoring shell Script using Systemd, Apache, MariaDB simple automation for Linux server Auto Recovery


May 22nd, 2026

linux-self-healing-wordpress-script-automation-how-to-auto-recovery-broken-apache-mysql-mariadb-wordpress-server-tux-logo

Running a WordPress website in production is not only about publishing content  it is also about keeping the server healthy 24 / 7 to have a good yearly Website Uptime and if needed fit an SLA.

Even on stable Linux systems, services occasional failures are common for a reasons like:

  • Apache Crash / stop responding (due to bug or whatever)
  • MariaDB Database server acts unstable after heavy load (or server overheat)
  • WordPress platform auto updates leaves the site stuck in maintenance mode (until manually fixed)
  • Network outage (or a DHCP server malfunction, IP / MAC conflics can disrupt network).

There is plenty of other things that can go wrong, but generally usually a website infrastructure running on a Linux server that counts for proper productivity on basically a web server (apache) / mariadb / postgresql (or whatever other service) and WordPress based website has a set of common issues faced. That require a sysadmin to partake simple steps to resolve it.
Temporary outages can become kind of permanent without proper monitoring and introduction of automatic recovery procedures.

Within the age of clouds and automation reducing outages is key to success!

To reduce downtime and avoid manual intervention, there is a lot of things a sysadmin can do but a lot of traditional options are mostly neglected or uknown by the the new and knowledgable SREs (Site Reliability Engineers), most of whom seem to be a Gen-Z 🙂

Thus an alternative approach to the new ways of working is to keep up to the old standards and use lightweight self-healing Bash monitoring script for my WordPress based site / blog. I use such script myself as a do have a self-hosted infrastructure, so decided to share it with hope someone can benefit of it.

The server-health-check-restore-wp-apache-mariadb.sh script continuously checks:

  • Apache health state
  • MariaDB availability
  • HTTP response code status equals 200 ( OK )
  • WordPress maintenance mode (is not disabled

As an auto healing steps It then partakes:

  • Restarts of found failed services
  • Cleans stuck . maintenance wordpress files
  • Reboots the entire server after repeated database failures

This approach provides a simple but highly effective watchdog mechanism without needing complex monitoring software.

1. The server-health-check-restore-wp-apache-mariadb.sh
automation self-healing Script

 

$ cat /usr/local/bin/server-health-check-restore-wp-apache-mariadb.sh

#!/bin/bash

URL="https://www.pc-freak.net/blog/"
MAINT_FILE="/var/www/blog/.maintenance"
KEYWORD="Briefly unavailable for scheduled maintenance"

APACHE_SERVICE="apache2"
MARIADB_SERVICE="mariadb"

MAX_DB_RESTARTS=5
RESTART_COUNT_FILE="/var/run/mariadb_restart_count"

log() {
    echo "$(date): $1"
}

# —- Apache check —-
if ! systemctl is-active –quiet "$APACHE_SERVICE"; then
    log "Apache is not running. Restarting…"
    systemctl restart "$APACHE_SERVICE"
    sleep 5
fi

# —- MariaDB check —-
if ! systemctl is-active –quiet "$MARIADB_SERVICE"; then
    log "MariaDB is not running."

    # Read restart count
    if [ -f “$RESTART_COUNT_FILE” ]; then
        RESTART_COUNT=$(cat "$RESTART_COUNT_FILE")
    else
        RESTART_COUNT=0
    fi

    RESTART_COUNT=$((RESTART_COUNT + 1))
    echo "$RESTART_COUNT" > "$RESTART_COUNT_FILE"

    log "Restart attempt $RESTART_COUNT of $MAX_DB_RESTARTS"
    systemctl restart "$MARIADB_SERVICE"
    sleep 10

    # Re-check MariaDB
    if ! systemctl is-active –quiet "$MARIADB_SERVICE"; then
        log "MariaDB still unhealthy after restart."

        if [ “$RESTART_COUNT” -ge “$MAX_DB_RESTARTS” ]; then
            log "MariaDB failed $MAX_DB_RESTARTS times. Rebooting server!"
            rm -f "$RESTART_COUNT_FILE"
            /sbin/reboot
            exit 0
        fi

        exit 0
    fi
else
    # MariaDB healthy → reset counter
    if [ -f “$RESTART_COUNT_FILE” ]; then
        log "MariaDB is healthy again. Resetting restart counter."
        rm -f "$RESTART_COUNT_FILE"
    fi
fi

# —- HTTP sanity check —-
HTTP_CODE=$(curl -L –max-redirs 5 -s -o /dev/null -w "%{http_code}" –max-time 10 "$URL")

if [[ “$HTTP_CODE” != “200” ]]; then
    log "Site returned HTTP $HTTP_CODE. Skipping WordPress maintenance cleanup."
    exit 0
fi

# —- WordPress maintenance check —-
PAGE_CONTENT=$(curl -L –max-redirs 5 -s –max-time 10 "$URL")

if echo "$PAGE_CONTENT" | grep -qi "$KEYWORD"; then
    if [ -f “$MAINT_FILE” ]; then
        rm -f "$MAINT_FILE"
        log "WordPress maintenance file removed."
    else
        log "Maintenance message detected, but .maintenance file not found."
    fi
else
    log "Site healthy. No maintenance mode detected."
fi

1.1. Make script executable

Store the script somewhere under /usr/local/bin/ and make it executable:

# chmod +x /usr/local/bin/server-health-check-restore-wp-apache-mariadb.sh

1.2. Schedule it to run via Cron job

Run the script lets say every 5 minutes with cron and make it log to a log file:

# crontab -u root -e

*/5 * * * * /usr/sbin/server-health-check-restore-wp-apache-mariadb.sh >> /var/log/wp_healthcheck.log 2>&1

2. What This Script Actually Does

The script acts like a mini watchdog daemon.

Instead of relying on heavyweight enterprise monitoring systems, it uses:

systemctl , curl , grep combined with simple scripting  logic.

The simplicity of solution advantage is for maintenance it is easy it is transparent and highly portable as it will run on virtually ever Linux server / VPS without the need to install anything additional.

2.1 Apache Health Checks

The first section checks whether Apache is running:

# systemctl is-active –quiet apache2

If Apache is down, the script automatically restarts it:

# systemctl restart apache2

This solves temporary crashes caused by:

  • memory exhaustion
  • bad PHP workers
  • failed reloads
  • temporary kernel pressure

A short sleep delay gives Apache time to recover before additional checks continue.

2.2. MariaDB Recovery Script Logic

The database layer is more critical than Apache.

A web server can recover instantly, but repeated MariaDB crashes often indicate:

  • corrupted tables
  • exhausted RAM
  • deadlocks
  • disk problems
  • InnoDB failures

Because of that, the script implements a restart counter.

2.3. Restart Counter Logic

The counter is stored in file:

/var/run/mariadb_restart_count

Every failed startup increments the counter:

RESTART_COUNT=$((RESTART_COUNT + 1))

If MariaDB recovers successfully, the counter is deleted.

This prevents accidental reboot loops.

2.4. Automatic Server Reboot if too many auto recovery attempts

If MariaDB fails too many times:

MAX_DB_RESTARTS=5

the script escalates to a full system reboot:

/sbin/reboot

2.5. Why use reboot at continuous services failure?

Well reboot might not always work and under some cases it can make things better, but in case if you have a multiple servers running the same set of service with Apache and Mysql  with Haproxy or other Load balancer in front this set of logic is just perfect:

  • kernel resources are exhausted
  • filesystem locks remain stuck
  • memory fragmentation becomes severe
  • hardware drivers misbehave

A clean reboot can recover the machine faster than manual debugging during production outages !

This kind of script can be especially useful on:

  • Rarely mainteinaed Linux / VPS servers
  • unattended cloud instances
  • remote hosting environments

2.6. HTTP Sanity Check

After validating services, the script checks whether the website actually responds correctly.

$ curl -L –max-redirs 5

The script expects as normal a return code of:

HTTP 200

Anything else:

  • 500 errors
  • redirect loops
  • gateway failures
  • CDN problems

will stop the maintenance cleanup logic.

This prevents accidental removal of WordPress maintenance files during unrelated outages.

2.7. Automatic WordPress Maintenance Mode Recovery

One of the most annoying WordPress problems happens during failed updates.

WordPress creates under its install directory say /var/www/ a file:

.maintenance

If the update crashes, the file remains forever and the site displays:

“Briefly unavailable for scheduled maintenance.”

The script detects this message directly from the webpage content with grep:

$ grep -qi "$KEYWORD"

If detected, it removes the stale file automatically:

rm -f "$MAINT_FILE"

This instantly restores the site without requiring manual SSH intervention.

3. Why Simple script approach Works well and is good idea

This setup has several advantages, among key one is It is Extremely Lightweight.

No additional complications of use of trendy stuff like:

  • Docker stack
  • Zabbix
  • Kubernetes
  • Prometheus
  • external monitoring agents etc.

Everything is handled with simple native well known Linux tools.

3.1. It is Easy to Debug

Everything is plain Bash.

No hidden automation layers.

Every action is visible and understandable.

3.2. Production Friendly

The script tolerates:

  • temporary outages
  • service crashes
  • failed WordPress upgrades

without requiring administrator interaction.

4. Possible future script Improvements

There are many ways to extend script setup further, here is few ideas.

4.1. Add Email Notifications

Send alerts when:

  • services restart
  • reboot occurs
  • maintenance mode is detected

4.2. Add Disk Space Monitoring

Automatically detect:

  • full disks
  • inode exhaustion
  • backup growth

4.3. Add simple MySQL Query Health Checks

Instead of only checking the service state:

mysqladmin ping

could validate actual database responsiveness.

4.4. Introduce systemd Integration

Instead of cron-based execution, you might want to make the script could be made native if you use :

  • systemd timer
  • systemd service

Close up Summary

In many cases, simple Linux automation still beats overengineered solutions.

Today overcomplication of monitoring is a trend especially for big companies however for home brew small projects on little budget, sometimes the best server automation is the simplest one.
 A few lines of Bash can improve as shown above could improve uptime and reduce operational headaches.

For small-to-medium WordPress / Website deployments, this kind of self-healing “watchdog “ guarantees you reliability , simplicity , transparency , relatively quick fast recovery in case of crashes without brining a any  unnecessary infrastructure complexity, plus this setup works with zero human interaction and if combined with a simple Slack / Discord monitoring python script you can sleep better.

 

No Comments »

« Previous Post

How to tell yum to pick up a missing package from a local directory when updating


May 20th, 2026

When maintaining older RHEL, CentOS, AlmaLinux, Rocky Linux OS (legacy) installs, or HA cluster systems, you may (and will perhaps) occasionally hit RPM dependency problems during updates because a required package is missing from the currently enabled repositories.

One common scenario you mighty face is when the required missing RPM exists in another repository or on local storage, but YUM/DNF does not automatically pick it up, due to mismanaged central repositories, broken proxies or even OS package release bugs.

In this article shows how to solve these dependency issues by using local RPM directories and temporary repositories.

Here is a typical Error example:

# yum update

  • Updating Subscription Management repositories.
  • Unable to read consumer identity
  • This system is not registered with an entitlement server.
  • You can use subscription-manager to register.

The Error faced is:

# yum update

Last metadata expiration check: 0:00:20 ago on Tue 19 May 2026 11:15:32 AM CEST.

Problem: cannot install the best update candidate for package corosync-3.1.8-1.el8.x86_64

  – nothing provides corosynclib(x86-64) = 3.1.8-1.el8_10.1 needed by corosync-3.1.8-1.el8_10.1.x86_64 from rhel-8-rhsm-ha

(try to add '–skip-broken' to skip uninstallable packages or '–nobest' to use not only best candidate packages)

 

Here as you can read from the error:

corosync update is available but the currently enabled repositories do not provide it, as the required package corosynclib exists elsewhere.

This often happens for reasons like

  • Partially mirrored REPO systems,
  • Network disconnected environments,
  • On expired RHEL OS subscription,
  • or migrated CentOS / RHEL (physical systems on another network or migrated VMs to another DC),
  • Custom (old) EOL HA cluster setups.
  • etc.


The missing RPM packages work around

There areat least  4 ways to fix YUM / DNF missing RPM packages:

  1. Install the RPM directly
  2.  Create a temporary local repository
  3. Add another repository dynamically
  4. Use –repofrompath / Use –nobest as a fallback workaround (Not recommended)

1. Install the missing RPM directly from local file copy 

If you already have the required package downloaded:

# yum install /root/packages/corosynclib-3.1.8-1.el8_10.1.x86_64.rpm

Try update retry:

# yum check-update

# yum update

YUM will now resolve dependencies successfully.

2. Create a Local Repository and put the missing package in

This is the cleanest solution if you maintain multiple RPMs.

a)  Create Directory

# mkdir -p /root/localrepo

b) Copy RPMs to localrepo

# cp corosynclib-*.rpm /root/localrepo/

c) Install createrepo

# yum install createrepo

d) Generate repo Metadata

 

This is done with createrepo command the command is provided by a package RPM package “createrepo_c” so if you have it missing you will have to install it (note in older RPM distros the cmd was provided by createrepo)

# createrepo /root/localrepo

Add Repository Definition

Create local.repo :

# vim /etc/yum.repos.d/local.repo

Add:

[local]

name=Local Repository

baseurl=file:///root/localrepo

enabled=1

gpgcheck=0

e.  Rebuild Cache and retry update again

# yum clean all

# yum makecache

Retry the update:

# yum update

YUM / DNF will automatically pull corosynclib from the local repository.

3. Use a temporary repository With –repofrompath

If you do not want permanent configuration files:

# yum –repofrompath=local,file:///root/localrepo \

    –enablerepo=local \

    update

 

This method is excellent for:

one-time fixes, for mass automation (fix wrong dependency on multiple servers), inside a rescue shells or if having to fix something offline on systems, that can’t be connected to the Internet.

4. Use another existing repository to pull the package from

If corosynclib exists in another disabled repository:

Check available repositories:

# yum repolist all

Then enable the required repository temporarily:

# yum –enablerepo=repo-name-corosync update

Or install directly:

# yum –enablerepo=repo-name-corosync install corosynclib

Then rerun the update.

Using –nobest yum option (not recommended) as cluster might break

Sometimes the newest package version has unresolved dependencies, while an older compatible package is still installable.

Try:

# yum update –nobest

This tells YUM/DNF not to insist on the newest possible package candidate.

This is often enough for partially synced repositories. But still this work around is not desirable as the HA cluster might break.

Note ! –skip-broken should not be used (a wrongly suggested “fix”)

The error message suggests:

# yum update –skip-broken

But this only skips the problematic package entirely.

!! Meaning it will most lilkely make corosync outdated, cluster nodes may become inconsistent, dependency issues remain unresolved.

Note ! For HA clusters and production systems, fixing the dependency properly is the right safe way to go.

On RHEL 8+, AlmaLinux 8+, Rocky Linux 8+, and Fedora having the package downloaded manually from a repo and using dnf is enough to have it installed:

# dnf install /root/packages/corosynclib*.rpm

or (if you have created a localrepo)

# dnf –repofrompath=local,file:///root/localrepo update

Closing Summary

Dependency resolution failures are often caused by repository inconsistencies rather than broken packages themselves. Trying work arounds without providing for the package manager the missing package will certainly lead to issues so try to abstain it at all costs.
If the missing RPM exists elsewhere, YUM and DNF can usually be guided to it by using the good old direct RPM install, using a temporary repository containing the package by enabling additional repo, using –repofrompath or taking a minute to prepare yourself a local repository and placing the missing package/s that should be enough to fix it.

No Comments »

« Previous Post

Why modern Linux systems feel Slow and how to Speed it up. Common RAM, CPU, and performance Linux problems in 2026 explained


May 18th, 2026

For years Linux we the Linux users proudly mocked Windows for bloated resource usage and that was a reason for many enthusiasts like me to start in the Linux realm.
There used to be the good old times where, lightweight distributions running comfortably inside 128MB of RAM were once common, and old computers and the hackers good old ThinkPads series were perfect for becoming a computer professional.

Fast-forward trip to 2026 and many modern GNU / Linux desktop's resource hunger has topped UP and a typical GUI environment such as Gnome is consuming as minimum 2 GB of RAM and often  4GB of RAM immediately after enters through the Login manager and machine. So many of the old computers if even running for 7-8 years and served well once updated or reused with Linux on a fresh install  prformance feels really bad. There of course work arounds to that as there are distributions such PuppyLinux / Tiny Core Linux / Linux Lite / Lubutuntu and even multiple articles online suggesting on how to place an ordinary Debian on Ubuntu and optimize it to work better on older hardware but still this article might be of help not only for old school Linux fans who install on old harware but also for sysadmins who has to deploy and install brand new Linux distributions and want to squeeze best of performance from the machine and make it as minimimalistic as possible in order to reduce the number of problems that might occur for system management.

So What happened, to make Linux performance degrade so dramatically over last 15 years ?

Old Hardware feels Slower Even With Linux

People often install Linux expecting miracles on ancient hardware.

Modern workloads assume:

  • SSD storage
  • multiple CPU cores
  • AVX instructions
  • GPU acceleration
  • large memory pools

Even lightweight Linux distributions struggle when rendering modern web applications on decade-old CPUs.

A 2007 machine browsing modern JavaScript-heavy websites experiences a fundamentally different workload than it did originally.

Web site use became computationally expensive.

 

Modern Linux Is Carrying the Weight of the development of Tech and Internet industry

A contemporary Linux desktop is no longer just:

  • X11
  • a window manager
  • a browser
  • a terminal emulator

Modern systems now run dozens of background services (as people run into complexity more and more instead of minimalism). Even a basic Linux install often runs by default things such as:
telemetry collectors, hardware abstraction layers, sandboxing frameworks, package management daemons, web server management platforms, indexing systems, GPU compositors, browser engines that resemble miniature operating systems and even with some specific distros embedded containers.

A typical desktop session environment on Linux today often includes as a base a bunch of software that is not always necessery such as:

  • systemd
  • dbus-daemon
  • pipewire
  • wireplumber
  • NetworkManager
  • xdg-desktop-portal
  • gvfsd
  • tracker-miner
  • udisksd
  • polkitd
  • bluetoothd
  • ModemManager
  • cupsd
  • flatpak-session-helper

Many younger users won't  never notice the burden of having those services running all time on the hardware as hardware today is mostly powerful and modern PC and notebooks often ship with 16GB or even some gaiming machines have 32 GB of memory.

As the default amount of memory on a laptop PC has become so abundant as 16GB RAM has become  "normal / standard ",  so software developers stopped aggressively optimizing memory consumption, plus the inclusing of AI vibe coding today and the abundant resource makes things with program optimization even more bloated.

The result of all this is more and more software entropy (the tendency of software systems to become more disorganized, complex, and harder to maintain over time).

The older UNIX philosophy no longer remembered by newer developers is completely forgotten. The old unix thinking was "Do one thing well.",
the new is "use everything no matter the efficiency if that would save you time"

As a result modern desktop applications instead ship entire browser engines for  simple things as displaying buttons.
This is exactly where Linux desktop gets heavily loaded and cause for whole system to work sluggish even on newer hardware. 
Very large part of those ineffiicient developed is caused by Electron:

Electron Framework for building Desktop apps worsened Linux performance

One of the largest reasons modern Desktop Linux / Windows systems is Electron (a framework for building desktop applications using JavaScript, HTML, and CSS).

Electron bundles essentially with:

  • Chromium
  • Node.js
  • V8 JavaScript engine
  • application runtime
  • UI rendering engine

and this is used in …inside many of the third party applications, which unfurtunately has to be used also on Linux, few examples that has heavy electron use are:

  • Discord client
  • Slack client
  • VS Code
  • Element 
  • Spotify
  • Visual Studio Code
  • Discord
  • Signal Desktop
  • Postman
  • Countless App launchers part of extra packages that one needs to use on Linux Desktop

…are frequently separate Chromium instances or use large part of chromium libs pretending to be native applications.

1. Finding top resource hungry Apps on Linux

To get a list of most memory heavy Apps on a Linux system:

# ps aux –sort=-%mem | head

 

You may discover that “lightweight desktop apps” and background services are consuming much more RAM than imagined.

Measuring Real Resource Usage Properly

Many users misunderstand Linux memory reporting.

Linux aggressively uses RAM for:

  • filesystem cache
  • buffers
  • inode caching

Note! Unused RAM is wasted RAM.

# free -h

Focus on:

  • available memory
  • swap activity
  • sustained pressure

Better command tools to optimize OS include:

htop
btop
smem
iotop
vmstat

Systemd  Useful but running default unused services

Mentioning systemd still starts wars on Linux forums.

Reality is nuanced.

Systemd solved real problems:

  • dependency management
  • predictable service startup
  • cgroup integration
  • journal logging
  • parallel boot
  • service supervision

However, it also dramatically expanded the scope of PID 1 responsibilities.

Leading to many Linux-es to now launch numerous services laying around, not known by the users and never (intially needed).

If you want to check and optimize systemd ecosystem to improve performance

2. Check systemd OS boot chain and disable unnecessery services

# systemd-analyze blame

And inspect active systemd units:

# systemctl list-units –type=service

Many Linux distributions has by default setup of unused:

  • printer services on systems without printers
  • modem services on desktops without modems
  • Bluetooth stacks on machines without Bluetooth devices
  • indexing daemons nobody uses

Disable unnecessary services carefully:

sudo systemctl disable –now ModemManager
sudo systemctl disable –now bluetooth
sudo systemctl disable –now cups


This alone will reduce memory usage and boot time.
A common set of unused Apps on Desktop and servers goes like this:
 

# Printing system (disable if you never use printers)

# systemctl disable –now cups.service cups-browsed.service

# Bluetooth support (disable if you don’t use Bluetooth devices)

# systemctl disable –now bluetooth.service

# Mobile broadband / modem support (disable if no 4G / 5G dongles)

# systemctl disable –now ModemManager.service

# Network discovery (AirPrint, LAN service discovery; disable if not needed)

# systemctl disable –now avahi-daemon.service

# Location services for apps/browser geolocation (disable if not used)

# systemctl disable –now geoclue.service

# Ubuntu crash reporting services (safe to disable for privacy/no reporting)

# systemctl disable –now apport.service whoopsie.service

# Desktop search indexing (GNOME file search; disable if you don’t use fast search)

# systemctl disable –now tracker-miner-fs.service tracker-extract.service tracker-store.service

 

For deeper analysis check out systemd cg groups use:

# systemd-cgtop

Or inspect slab allocator usage:

slabtop


3. Avoid using Flatpak and Snap for extra Apps

Flatpak and Snap Increase Isolation, provides many modern Apps that are not default shipped by Debian / Ubuntu / Fedora OS  etc (Deb / RPM) repos and keeps packages easily at latest but also puts great worthless overhead on system.
 

a) Modern packaging systems like Flatpak and Snap (Pros) prioritize:

  • sandboxing
  • dependency isolation
  • reproducibility
  • cross-distribution compatibility

This is good for security, however it comes at a cost.

b) Use of Flatpak and Snap pack. managers downsides

Flatpak applications frequently duplicate:

  • runtimes
  • libraries
  • graphics stacks
  • helper services

Snap packages compress applications into loop-mounted filesystem images which increase startup overhead and general memory fragmentation.

Inspect mounted Snap filesystems

# mount | grep snap


Inspect Flatpak runtimes:

# flatpak list


Considering that, traditional native packages remain significantly leaner in many cases.

4. Use Minimalistic GUI Desktop environment to reduce resource and use of complexity on Linux

Being mimimalist nowadays in a world of abundancy is considered wrong. However minimalism has its well known provent benefits. 

Wayland Is Efficient,  but X11 env with Minimalist GUI is better

Wayland itself is not inherently bloated.

However, modern compositors increasingly rely on:

  • GPU acceleration
  • animation pipelines
  • texture buffering
  • fractional scaling
  • HDR rendering
  • Vulkan / OpenGL abstractions

This improves:

  • smoothness
  • latency
  • security
  • multi-monitor support

…but increases baseline GPU and memory usage and still for performance cautious desktop users it is most likely not the best option.

For example, try to compare CPU / Mem / Disk use of:

  • Openbox on X11
  • KDE Plasma on Wayland with effects enabled

The performance difference is dramatic.


If you want to be a Linux Minimalist (benefit) and get astonishingly low resource usage try:

  • dwm
  • i3
  • bspwm
  • Openbox
  • Wmaker
  • XFCE
  • IceWM

Switching to one of those Linux ecosystem instead of the default heavy GNOME or KDE permits even further optimizations on Graphical environment level,  if users intentionally choose it. The downsides of that is twitching it will take you usually longer but if you setup one and the same desktop with the basic minimalist environment and you keep using it for daily work / development for years, invested time is worth.

5. Use browser extensions, habits or a lightweight  browser. 

Web browser a common source of slowness 

Web Browsers, became nowadays a fully featured Operating Systems. On many machines they are the largest consumers of RAM on Linux systems and on old computers main source of slowness. On older PCs try to use other small browser alternatives

A single browser tab may include:

  • isolated sandbox process
  • JavaScript runtime
  • GPU process
  • extension subsystem
  • video decoder
  • site isolation sandbox
  • service workers

a) Inspect Chromium process trees

# ps -ef | grep chromium

b) Inspect Firefox process trees

about:processes

 

A few “simple” tabs can easily consume several gigabytes.

The modern web itself is bloated:

  • gigantic JavaScript frameworks
  • endless analytics
  • autoplay video
  • AI scripts
  • tracking engines
  • real-time rendering

Shamefully, many websites today consume more RAM than entire operating systems from the early 2000s.

If you have to work on a PC with 4 or 8 GB with Linux maybe you can try to use a GUI browser only when necessery and for general reading and stuff use a minimalist version of browsers such as using a text / console web  browser and ones that are capable to support ncurses and javascript partially, a good candidate for a real console maniac or an old school hacker will be some of below:

  • Lynx (lightest, pure text)
  • w3m (text browser but supports javascripts partially)
  • Links / Links2 (fast, ultra-lightweight web browser works in both text and gui modes)
    NetSurf (graphical web browser built from scratch with its own independent layout and rendering engine, performs poor with javascript)
  • Browsh (can be often used instead of fully functional browser but buggy)

xlinks2-graphical-mode-lightweight-browser-linux

c) Use Lightweight Browsing Habits

Extensions matter enormously.

Block:

  • ads
  • trackers
  • autoplay
  • unnecessary scripts

uBlock Origin (free and open source browser block extension) alone can dramatically reduce CPU and RAM consumption.

Final words; the modern computing efficiency degredal

What a paradox, Modern hardware is unbelievably powerful, yet modern software consumes resources at almost the same rate hardware improves.

This phenomenon is partially explained by:abstraction layers, developer convenience, use of cross-platform frameworks, increased security isolation, the web technologies heaviness and reduced optimization pressure.

Even though the degredal in perforamance on old hardware, Linux itself remains extremely efficient at the kernel level.

The bloat largely exists and widens though in:

  • userland
  • desktop ecosystems
  • browser-centric software culture
     

The computing as we know it changed.

What once was: terminal-centric, native, lightweight,locally optimized, inter-dependent

turned over  last 10 years: browser-centricm, all time cloud-connected, sandboxed, abstraction-heavy, outer dependent

The good news is that GNU / Linux still gives users freedom, even though the freedom has reduced.

Even though the performance reduced,  Linux still remains one of the few environments where users retain meaningful control over their data and system complexity in the AI, Clouds era

 

No Comments »

« Previous Post

Speed up Linux shell use keyboard command alias shortcuts to effiently work like a hacker


May 1st, 2026

speed-up-linux-shell-use-via-keyboard-command-alias-shortcusts-to-work-like-a-hacker-and-be-efficient

If you want to get truly fast in the Linux Bash shell, stop thinking in commands alone and start doing trivial command tasks by thinking it in keystrokes !
The biggest productivity gains don’t come only by learning new tools, they come from navigating and reusing what is embedded as default functionality, like editing commands , searching through them and shortcuts to run and reuse instantly without need to type again and again.

At the center of this approach is one habit, to try to never type the same command twice.

1. The Allmighty, Reverse Search (Ctrl + R)

If you learn only one shortcut for a begginning say hello to the King of all bash shortcut commands CTRL + R.

Press: 

Ctrl + R

Then start typing part of a previous command. Bash will search your history in real time and show the most recent match.

Example: 

(reverse-i-search)`ssh': ssh user@server

Press:
To cycle further one command match back:

Ctrl + R


again 

Edit before running use:

→ (right arrow)

To run found cmd simply press Enter.

This is dramatically faster than scrolling through history or retyping long commands. Over time, your shell history becomes a searchable command database.

2. Stop annoying re-typing: navigate the Line instantly

When editing a command, don’t hold arrow keys—jump instead:

Go to the beginning of line

Ctrl + A

Move to the end of command string:

Ctrl + E

Jump back one word

Alt + B

Jump forward one word ahead

Alt + F

These shortcuts let you fix mistakes or modify long commands in seconds.

3. Precise Delete strings

Precise deletion is just as important as movement:

Delete everything before cursor position:

Ctrl + U 

Delete everything after cursor position:

Ctrl + K

Delete previous word from cmd string:

Ctrl + W

Delete next word in command string

Alt + D 

Instead of holding backspace, you surgically remove chunks of text.

4. Reuse arguments without rewriting

Bash has built-in shortcuts for reusing parts of previous commands:

Repeat last command, type in shell

!!

Last argument of previous command

!$

Add all arguments from previous command to a command

!*


For example on use last argument from previous command: 

mkdir project
cd !$

This jumps into the directory you just created without retyping its name.
 

hipo@jeremiah:/usr/local/bin$ find . /usr/local/bin/ /bin/ /usr/bin -iname 'ls'

/bin/ls

/usr/bin/ls

hipo@jeremiah:/usr/local/bin$ echo !*

echo . /usr/local/bin/ /bin/ /usr/bin -iname 'ls'


To only get the file name of

5. Fix Mistakes Instantly hack

Made a typo? You don’t need to retype the whole command.

Use the shortcut: 

^old^new

Example: 

hipo@jeremiah: ~$ ls -al /bin/sl
ls: cannot access '/bin/sl': No such file or directory
hipo@jeremiah: ~$ ^sl^ls
ls -al /bin/ls
-rwxr-xr-x 1 root root 151344 Sep 20  2022 /bin/ls

Bash reruns the previous command with the correction applied.

6. Use history without running history cmd

The quick access to last and previous commands, is perhaps known by most but for novice people starting will shell it is worthy mention:

Scroll through commands:

Keyboard Arrow Up / Down keys ↑ / ↓

run command number n from history !n:

To re-run cmd from history line 10

$  !10

To lets say you want to get last 10 commands from history:

$ history 10

Instead of getting full comand history with

$ history

Use the Ctrl + R which is faster shortcut to arrow keys and walking through history.

7. Use Auto-Complete

The good old well known Tab key is well known one by almost all sysadmins, but I’ll mention it anyways.

Auto-complete file / command
Single Tab press

Show all matches
Press Tab twice

This reduces typing and prevents errors – especially with long file paths.

8. Edit the previous command straight in editor

For complex commands, use: 

Ctrl + X, Ctrl + E

This opens your last command in your default editor. You can comfortably edit multi-line or complicated commands, then save and execute.

9. Clear and Reset Quickly

Clear the screen (same as clear):

Ctrl + L

Cancel current command:

Ctrl + C

Exit shell:

Ctrl + D 

These keep your terminal clean and under control.

10. Background and Foreground Control

You can manage running processes with the keyboard too:

Pause (suspend) active running process on cmd line:

Ctrl + Z

Resume process in background:

$ bg

Bring back to foreground:

$ fg  

This is especially useful when you accidentally start something in the foreground.

11. Memorize shortcuts / improve shell habits

When these shortcuts become automatic, habit for you will soon reap the benefits.

You will then no longer need to, constantly retype long command lines, you will not loose time to point with the mouse, you save time on editing your command line:

Of course getting it as habit will take few hours to a day.

Start with just building two habits:

  1. Use Ctrl + R instead of retyping

  2. Use Ctrl + A / Ctrl + E instead of arrow keys

Once those stick, layer in the others.

 

12. Start using fzf fuzzy finder command utility

 

To get even better command line search and easier manage things with command line binds use fzf.
 

# apt install –yes fzf

$ source /usr/share/doc/fzf/examples/key-bindings.bash


The fzf command-line tool enhances Linux terminal productivity by replacing the standard, rigid Ctrl+R history search with interactive, real-time fuzzy matching.
It offers a visual interface for searching command history, file paths via Ctrl+T, and directories using Alt+C [Source]. Installing fzf enables a highly efficient workflow, allowing users to find and execute commands faster.

 For a complete use cases check GitHub fzf page.

Final Thought

Efficient command line use in Bash is not only about doing less typing, it is about doing more work with less effort, so you can have more time for the important stuff.
The keyboard shortcuts are already there for long time and computer hackers (i mean old school system programmers) has been using them for ages not only in bash but in ksh, zsh, csh and  waiting to remove friction from everything you do.
Master them, and the shell stops being a place where you type in like a secretary, but a enjoyable more fun place to spend time on.

 

1 Comment »

« Previous Post

How to Create the Latest Windows 10 / 11 Installation Media from Linux OS


April 20th, 2026

create-a-windows-installation-flash-drive-from-linux-logo-howto-create-windows-media-os-installer

Creating a Windows 10 installation USB from a Linux system is entirely possible and surprisingly straightforward once you know the few steps process and using few Linux tools. Whether you're preparing a dual-boot setup, fixing a broken Windows machine OS onplace, or re-installed Windows, installing fresh from scratch, is an useful skill every self-respecting sysadmin should be aware of.

Why Create Windows Installation Media from Linux ?

Even a hardcore Linux sysadmin / Desktop users need Windows for specific software, gaming, or troubleshooting, or for deployment of Windows installs for non-IT professionals, friends or company environments.
Having a Windows installable ISO by downloading and using Windows Media Creation Tool is an easy trivial task for those with Windows but is a problem especially for GNU / Linux users like me who don't own a computer with Microsoft Windows, but have Debian / Ubuntu / Fedora in place. 
Microsoft’s official media creation tool is made to only runs on Windows OS, fortunately there is a few ways to have an installable USB drive prepared even on Linux.

The main challenge lies in properly formatting the USB flash drive and handling large Windows image files, especially the install.wim, which can exceed FAT32 file size limits.

What You’ll Need

Before starting, make sure you have:

  • A USB drive (at least 8GB sized recommended)
  • A Linux system (Ubuntu, Fedora, Arch Linux etc.)
  • The latest Windows 10 ISO file (downloaded locally)

1. Download the Windows 10 ISO

Go to Microsoft’s official website and download the latest Windows 10 ISO. You can do this directly from Linux using your browser.

  1. Go to the Official Windows 10 Download Page.
  2. On Windows: Press F12 (Dev Tools), click the Device Toolbar icon (mobile/tablet icon), and refresh the page. This tricks Microsoft into thinking you are on a Mac or Linux machine.
  3. Select the edition and language, then click Confirm.
  4. Right-click the 64-bit Download button and select Copy link address.
  5. In your terminal, use wget. Note: You must wrap the URL in double quotes because it contains special characters:


Use wget with  a direct copy of download link like for example:

$ wget https://www.microsoft.com/software-download/windows10.iso -O windows10.iso

Make sure the ISO is fully and correctly downloaded before proceeding further.

2. Install Required Tools

On Debian / Ubuntu deb-based distros. You’ll need few utilities:

# apt update # apt install wimtools ntfs-3g p7zip-full

On Fedora:

# dnf install wimlib ntfs-3g p7zip

These tools help extract and handle Windows image files properly.

3. Prepare the USB Drive

Insert your USB drive and identify it:

# lsblk

Look for something like /dev/sdb (be careful, as this will erase all data on the drive).

Partition and Format

Use fdiskor parted:

# fdisk /dev/sdb

  • Create a new partition table (GPT or MBR)
  • Create one primary partition
  • Set type to NTFS or FAT32

Then format it:

# mkfs.ntfs -f /dev/sdb1

 

NTFS is recommended because it supports large files.

4. Mount ISO and USB

Create mount points:

mkdir ~/winiso mkdir ~/winusb

Mount the ISO:

# mount -o loop windows10.iso ~/winiso

Mount the USB:

# mount /dev/sdb1 ~/winusb

5. Copy Files of ISO to Flash drive

Copy all files from the ISO to the USB:

# rsync -avh –progress ~/winiso/ ~/winusb/

This may take several minutes.

6. Handle Large install.wim File (If Needed)

If you formatted your USB as FAT32 and encounter issues with large files:

Split the WIM file:

# wimlib-imagex split ~/winiso/sources/install.wim ~/winusb/sources/install.swm 4000

Then remove the original:

rm ~/winusb/sources/install.wim

This step ensures compatibility with FAT32 file size limits.

7. Safely Unmount

Once everything is copied, make sure to:

# umount ~/winiso # umount ~/winusb

Now your USB is ready.

! NB ! Ensure Boot Files Exist

Double-check this path exists (on the new created Flash stick):

/EFI/BOOT/bootx64.efi

If this file is missing, the USB will fail to boot Windows 11 OS Installer.

8. Boot from fresh created USB drive

Insert the USB flash drive into the target machine, reboot, and enter BIOS / UEFI (usually by pressing F2, F12, DEL, or ESC).

Select the USB drive as the boot device / Save settings, reboot and the Windows OS installer screen should appear.

9. Troubleshooting Tips and Common Pitfalls (Especially with Windows 11)

  • USB not booting ? – Ensure your system is set to boot in UEFI mode if your USB is GPT formatted.
  • Missing drivers ? – Try recreating the USB using NTFS instead of FAT32.
  • Secure Boot issues ? – You may need to disable Secure Boot in BIOS.

9.1. USB Not Booting

  • Try use FAT32 instead of NTFS

  • Ensure UEFI mode is enabled

9.2. “File Too Large” Error

  • Very likely you forgot to split install.wim (as prior described)

9.3. Installer Refuses to Continue

  • Windows 11 require:
    a.TPM 2.0
    b. Secure Boot

10. Alternative GUI Linux Tools to use WoeUSB-ng / Ventroy

If you prefer Linux GUI tools for preparation of Installation USB drive Media , consider downloading WoeUSB or Ventroy:

  • WoeUSB – specifically designed for creating Windows bootable USBs from Linux
  • Ventoy – allows you to copy multiple ISOs to a single USB and boot from a menu

10.1 Install WoeUSB-ng

Easiest and perhaps most straight forward way is to install it via git and pip python.

$ git clone https://github.com/WoeUSB/WoeUSB-ng.git

$ cd WoeUSB-ng

$ sudo pip3 install .

10.2. Install Ventroy and deploy Windows installer on USB Drive

 

a) Prepare the USB Drive in Linux

b) Add the Windows ISO 

c) Install Windows ISO

1. Download it : Get the ventoy-x.x.xx-linux.tar.gz file from the Ventoy website.

2. Extract : Open a terminal and extract: tar -xvf ventoy-*.tar.gz.

3. Locate USB: Run lsblk to identify your USB drive (e.g., /dev/sdb).

4. Install: Run the script (replace /dev/sdb with your drive):

# sudo ./Ventoy2Disk.sh -i /dev/sdb

 

Once installed, the USB will have a large partition named "Ventoy".


5. Copy, paste Windows ISO file: (Windows 10 or 11) onto this USB drive. 

 

6. Insert the USB,  into the target computer.

7. Reboot PC:  and enter the BIOS/boot menu (e.g., F2, F12) to boot from the USB.

Sum it up

Creating Windows 10 installation media from Linux might seem tricky at first, but with the right approach, it’s completely manageable, it is also a nice one if you need to create multiple flash drives, and you need to automate the process of Windows installable USB drive creation for multiple windows setups that needs to get reinstalled on place simultaneously.
Once you’ve done it once, it becomes a quick and reliable process you can reuse anytime.

Whether you're a Linux enthusiast or just working across systems, this method ensures you're never stuck without a Windows installer at hand, even without owing a Windows OS.

No Comments »

« Previous Post

The Gospel of the Second Resurrection (John 20:19–26) Bright Monday Gospel reading interpretation


April 12th, 2026

Resurrection-of-Christ-Bulgarian-Eastern_Orthodox-Christian-Miracle-making-icon
Christ is Risen ! Truly he is Risen ! 

Another year to celebrate Resurrection day, I great all my readers with the Holy and Glorious day of The Resurrection of Christ !
Happy Resurrection day, Happy Easter to All faithful Christians and all Technology Freaks out there who look for the Universal truth and meaning of life !

Happy Resurrection to those who are searching it and those who find it, as I tend to find more and more that more technological literate people came to become Christian and find the Light and truthfulness of Holy Orthodox Christian Faith !
 

In Orthodox Christianity, the Second Resurrection Service often called Agape Vespers is a deeply symbolic and joyful service celebrated on the afternoon or evening of Pascha, the feast of Christ’s Resurrection, an event that changed history forever and made the Time to be counted on Age before Christ and Age after him Anno Domini ( A.D. ) Christ's victory over death and importance of the Resurrection has become a turning stone for whole world and has one time forever changed the history to Bring the Light of Heaven on earth again after the fall of man in Eden's garden. 
In Orthodox Christian tradition the feast of Resurrection is being celebrated Staring from the Day of Pascha (The Resurrection of Christ) towards his Ascension on the Day of Ascension on the 40th Day. Many might not today, that the first 7 days Week of Pascha is actually a whole period of celebration like a day who marks The Resurrection and the whole week in Orthodox tradition is considered as one single day. The first 3 days when the Lord Jesus Christ raised to the death after being in Hell with his soul to Save and Save all the waiting souls of prophets and old testamental times of old righteous people and those who repented (on Holy Saturday) the Next day after Crucifix (on Holy Friday) are the Most glorious and important days of the whole 40 days period of the Resurrection till time the Lord Ascended to Heaven with his Glorious Resurrectied Body. 

The Paschal Church service of the Resurrection of Christ which is celebrated with serving Saint Basyl's Holy Liturgy in Orthodox Christian tradition always starts exactly at Midnight. In many traditions nowdays like also in Bulgarian tradition, the Holy Fire is brought by Plane to the Synodal Palace of the Church from hence it is distributed across local Pariches Churches to bring the Light of the Miracle of Jerusalem of Holy Fire that happen once and only for Eastern Orthodox Christians, when a Light of Heaven comes to light up the Candle of Jerusalem's Eastern Orthodox Christian patriarch as a eternal confirmation of the Truthfulness of the Resurrection of Christ (a God's sign for Unbelievers to think and study the Orthtoxy). The miracle of Holy Fire happened even this year in Jerusalem in the Holy Sepulcher Church (built on top of the Place of Resurrection of Christ). Thanks God even though humanity sinfulness (and the escalating wars) which by Miracle and God's grace and great Mercy has been temporary suspended for the World to mark the Feast of the Feast of The Resurrection. It is a clear miracle that this temporary peace in Ukraine and Russia as well as Israel and Iran happened exactly on the days of the Eastern Orthodox Christian resurrection, which is this year as most years one week later than the Roman Catholic pascha (as we at the Orthodox Church still do venerate righteously the rule of The first Church Council of Nicea.).

The reason to follow Easter differently for Eastern Orthodox Chrsitians from Western Roman Catholic Christians is often misunderstood and puts great confusion to explain especially to modern people from East and West faith that work together in corporations, thus I'll put a short explanation on why we Eastern Orthodox Christians celebrate Pascha often differently than Roman Catholics?:
There are 3 main reasons that sted from the Ecumenical council of Nicea:
 

  1. Separation from Jewish Timing: The Council mandated that Christians should no longer rely on Jewish calculations for the 14th of Nisan. The Emperor Constantine, in a letter following the council, argued that it was "unworthy" for Christians to follow the custom of those who had rejected Christ.
  2. Solar-Lunar Formula: To remain independent, the Council adopted the "Alexandrian method": Pascha must fall on the first Sunday after the first full moon occurring on or after the vernal equinox.
  3. Biblical Sequence: While the council's surviving canons do not explicitly state "after Passover," the Orthodox Church maintains that the Nicene intent was to preserve the Biblical sequence of events. Since the Resurrection happened after the Jewish Passover in the Gospels, the Orthodox calculation ensures Pascha never precedes or coincides with the start of the Jewish festival. 

On the next day after we celebrate the Feast of Resurrection (Velikden as called in Eastern tradition) is Bright Monday. The day is very special as the Night Vigil and Morning Service with Holy Liturgy ends up very late around 3, 3-30 A.M. And the service is created by Holy Fathers of the Church inspired by God as a way to experience for second time (on the same day)the Joy of the Resurrection, so the spiritual joy be even more multiplied and well undestood b the Church members.

The Bright Monday or Easter Monday in Eastern Orthodox Christian tradition is marked by what is often called the “Second Resurrection”service. 

The service is a continuation of the joy of Pascha, emphasizing the universal proclamation of Christ’s victory over death.

At the heart of this celebration is the Gospel reading from John 20:19–26, which recounts Christ’s first appearances to His disciples after the Resurrection. What is unique for the service is this is the only day in year when the One and Holy Universal Eastern Orthodox Church shows its universality and union and acceptance of all languages as a mean to proclaim the Good new of Salvation way the Holy Gospel introduced for everyone who believed in the name of the Jesus Christ as a Son of God and Savior of the World by Having introduced the reading of a Gospel reading in different nation languages ! 

Here is a selection of the Text reading as translated in different languages, might be helpful if you belong to one of those Churches abroad, to read the text on "Second Resurrection", bright monday Service:
 

English (King James Version)
John 20:19–26

Then the same day at evening, being the first day of the week, when the doors were shut where the disciples were assembled for fear of the Jews, came Jesus and stood in the midst, and saith unto them, Peace be unto you.
And when he had so said, he shewed unto them his hands and his side. Then were the disciples glad, when they saw the Lord.
Then said Jesus to them again, Peace be unto you: as my Father hath sent me, even so send I you.
And when he had said this, he breathed on them, and saith unto them, Receive ye the Holy Ghost:
Whose soever sins ye remit, they are remitted unto them; and whose soever sins ye retain, they are retained.
But Thomas, one of the twelve, called Didymus, was not with them when Jesus came.
The other disciples therefore said unto him, We have seen the Lord. But he said unto them, Except I shall see in his hands the print of the nails, and put my finger into the print of the nails, and thrust my hand into his side, I will not believe.
And after eight days again his disciples were within, and Thomas with them: then came Jesus, the doors being shut, and stood in the midst, and said, Peace be unto you.

Bulgarian (Synodal translation) 
Йоан 20:19–26

Вечерта в същия ден, първия на седмицата, когато вратите, дето бяха събрани учениците, бяха заключени от страх от юдеите, дойде Иисус, застана посред и им каза: Мир вам!

И като рече това, показа им ръцете и ребрата Си. Учениците се зарадваха, като видяха Господа.
Иисус пак им рече: Мир вам! Както Ме прати Отец, така и Аз ви пращам.
Като каза това, духна и им рече: Приемете Духа Светаго.
На които простите греховете, ще им се простят; на които задържите, ще се задържат.
А Тома, един от дванайсетте, наречен Близнак, не беше с тях, когато дойде Иисус.
Другите ученици му казваха: Видяхме Господа. А той им рече: Ако не видя на ръцете Му белега от гвоздеите и не туря пръста си в раните от гвоздеите и не туря ръката си в ребрата Му, няма да повярвам.
След осем дни учениците Му пак бяха вътре и Тома с тях. Дойде Иисус, когато вратите бяха заключени, застана посред и рече: Мир вам!

 Russian (Synodal) 
От Иоанна 20:19–26

В тот же первый день недели вечером, когда двери дома, где собирались ученики Его, были заперты из опасения от Иудеев, пришел Иисус, и стал посреди, и говорит им: мир вам!
Сказав это, Он показал им руки и ребра Свои. Ученики обрадовались, увидев Господа.
Иисус же сказал им вторично: мир вам! как послал Меня Отец, так и Я посылаю вас.
Сказав это, дунул, и говорит им: примите Духа Святаго.
Кому простите грехи, тому простятся; на ком оставите, на том останутся.
Фома же, один из двенадцати, называемый Близнец, не был тут с ними, когда приходил Иисус.
Другие ученики сказали ему: мы видели Господа. Но он сказал им: если не увижу на руках Его ран от гвоздей и не вложу перста моего в раны от гвоздей и не вложу руки моей в ребра Его, не поверю.
После восьми дней опять были в доме ученики Его, и Фома с ними. Пришел Иисус, когда двери были заперты, стал посреди их и сказал: мир вам!

Ἐκ τοῦ κατὰ Ἰωάννην ἁγίου Εὐαγγελίου τὸ ἀνάγνωσμα.
Greek (Κοινή / Patriarchal Text – Orthodox usage) 

Οὔσης οὖν ὀψίας τῇ ἡμέρᾳ ἐκείνῃ τῇ μιᾷ σαββάτων, καὶ τῶν θυρῶν κεκλεισμένων ὅπου ἦσαν οἱ μαθηταὶ συνηγμένοι διὰ τὸν φόβον τῶν Ἰουδαίων, ἦλθεν ὁ Ἰησοῦς καὶ ἔστη εἰς τὸ μέσον καὶ λέγει αὐτοῖς· Εἰρήνη ὑμῖν.
καὶ τοῦτο εἰπὼν ἔδειξεν αὐτοῖς τὰς χεῖρας καὶ τὴν πλευρὰν αὐτοῦ. ἐχάρησαν οὖν οἱ μαθηταὶ ἰδόντες τὸν Κύριον.
εἶπεν οὖν αὐτοῖς πάλιν ὁ Ἰησοῦς· Εἰρήνη ὑμῖν· καθὼς ἀπέσταλκέ με ὁ Πατήρ, κἀγὼ πέμπω ὑμᾶς.
καὶ τοῦτο εἰπὼν ἐνεφύσησε καὶ λέγει αὐτοῖς· Λάβετε Πνεῦμα Ἅγιον·
ἄν τινων ἀφῆτε τὰς ἁμαρτίας, ἀφίενται αὐτοῖς· ἄν τινων κρατῆτε, κεκράτηνται.
Θωμᾶς δὲ εἷς ἐκ τῶν δώδεκα, ὁ λεγόμενος Δίδυμος, οὐκ ἦν μετ’ αὐτῶν ὅτε ἦλθεν ὁ Ἰησοῦς.
ἔλεγον οὖν αὐτῷ οἱ ἄλλοι μαθηταί· Ἑωράκαμεν τὸν Κύριον. ὁ δὲ εἶπεν αὐτοῖς· Ἐὰν μὴ ἴδω ἐν ταῖς χερσὶν αὐτοῦ τὸν τύπον τῶν ἥλων καὶ βάλω τὸν δάκτυλόν μου εἰς τὸν τύπον τῶν ἥλων καὶ βάλω τὴν χεῖρά μου εἰς τὴν πλευρὰν αὐτοῦ, οὐ μὴ πιστεύσω.
καὶ μεθ’ ἡμέρας ὀκτὼ πάλιν ἦσαν ἔσω οἱ μαθηταὶ αὐτοῦ καὶ Θωμᾶς μετ’ αὐτῶν. ἔρχεται ὁ Ἰησοῦς τῶν θυρῶν κεκλεισμένων καὶ ἔστη εἰς τὸ μέσον καὶ εἶπεν· Εἰρήνη ὑμῖν.

 Serbian (Епископски / Orthodox usage)
Јован 20:19–26

А у вече тог првог дана седмице, кад су врата где беху ученици сабрани била затворена од страха од Јудејаца, дође Исус и стаде међу њих и рече им: Мир вам!
И ово рекавши, показа им руке и ребра Своја. Тада се обрадоваше ученици видевши Господа.
Тада им Исус опет рече: Мир вам! Као што је Отац послао Мене, и Ја шаљем вас.
И ово рекавши, дуну и рече им: Примите Духа Светога.
Којима опростите грехе, опраштају им се; којима задржите, задржани су.
А Тома, један од дванаесторице, звани Близанац, не беше с њима кад дође Исус.
Тада му други ученици говораху: Видели смо Господа. А он им рече: Ако не видим на рукама Његовим ране од клинова и не ставим прст свој у ране од клинова и не ставим руку своју у ребра Његова, нећу веровати.

И после осам дана опет беху унутра ученици Његови и Тома с њима. Дође Исус кад врата беху затворена, стаде међу њих и рече: Мир вам!

 Romanian (Biblia sinodală – Orthodox)
Ioan 20:19–26

Și fiind seară, în ziua aceea, cea dintâi a săptămânii, și ușile fiind încuiate unde erau ucenicii adunați de frica iudeilor, a venit Iisus și a stat în mijloc și le-a zis: Pace vouă!
Și zicând aceasta, le-a arătat mâinile și coasta Sa. Deci s-au bucurat ucenicii, văzând pe Domnul.
Și le-a zis iarăși Iisus: Pace vouă! Precum M-a trimis pe Mine Tatăl, vă trimit și Eu pe voi.
Și zicând aceasta, a suflat asupra lor și le-a zis: Luați Duh Sfânt.
Cărora veți ierta păcatele, le vor fi iertate; și cărora le veți ține, vor fi ținute.
Iar Toma, unul din cei doisprezece, numit Geamănul, nu era cu ei când a venit Iisus.
Deci ceilalți ucenici îi ziceau: Am văzut pe Domnul. Dar el le-a zis: Dacă nu voi vedea în mâinile Lui semnul cuielor și nu voi pune degetul meu în semnul cuielor și nu voi pune mâna mea în coasta Lui, nu voi crede.
Și după opt zile, ucenicii Lui erau iarăși înăuntru, și Toma împreună cu ei. A venit Iisus, ușile fiind încuiate, și a stat în mijloc și a zis: Pace vouă!
 

German (Luther tradition / Orthodox-used standard translation style)
Johannes 20,19–26

Und am Abend desselben ersten Tages der Woche, als die Türen verschlossen waren, wo die Jünger versammelt waren aus Furcht vor den Juden, kam Jesus und trat mitten unter sie und spricht zu ihnen: Friede sei mit euch!

Und als er das gesagt hatte, zeigte er ihnen die Hände und seine Seite. Da wurden die Jünger froh, dass sie den Herrn sahen.

Da sprach Jesus abermals zu ihnen: Friede sei mit euch! Gleichwie mich der Vater gesandt hat, so sende ich euch.

Und als er das gesagt hatte, hauchte er sie an und spricht zu ihnen: Empfangt den Heiligen Geist!

Welchen ihr die Sünden erlasst, denen sind sie erlassen; und welchen ihr sie behaltet, denen sind sie behalten.

Thomas aber, einer der Zwölf, der Zwilling genannt wird, war nicht bei ihnen, als Jesus kam.

Da sagten ihm die anderen Jünger: Wir haben den Herrn gesehen. Er aber sprach zu ihnen: Wenn ich nicht in seinen Händen die Nägelmale sehe und meinen Finger in die Nägelmale lege und meine Hand in seine Seite lege, so will ich nicht glauben.

Und nach acht Tagen waren seine Jünger abermals drinnen, und Thomas war bei ihnen. Kommt Jesus, als die Türen verschlossen waren, und tritt mitten unter sie und spricht: Friede sei mit euch!

Arabic (بطريركي / Orthodox liturgical usage)
إنجيل يوحنا 20:19–2

ولما كانت عشية ذلك اليوم، وهو أول الأسبوع، وكانت الأبواب مغلقة حيث كان التلاميذ مجتمعين خوفًا من اليهود، جاء يسوع ووقف في الوسط وقال لهم: سلام لكم.

ولما قال هذا أراهم يديه وجنبه، ففرح التلاميذ إذ رأوا الرب.

فقال لهم يسوع ثانية: سلام لكم. كما أرسلني الآب أرسلكم أنا أيضًا.

ولما قال هذا نفخ فيهم وقال لهم: اقبلوا الروح القدس.

من غفرتم خطاياه تُغفر له، ومن أمسكتم خطاياه أُمسكت.

أما توما، أحد الاثني عشر، الذي يُدعى التوأم، فلم يكن معهم حين جاء يسوع.

فقال له التلاميذ الآخرون: قد رأينا الرب. فقال لهم: إن لم أبصر في يديه أثر المسامير وأضع إصبعي في أثر المسامير وأضع يدي في جنبه لا أؤمن.

وبعد ثمانية أيام كان تلاميذه أيضًا داخلًا، وكان توما معهم. جاء يسوع والأبواب مغلقة، ووقف في الوسط وقال: سلام لكم!

Georgian (საქართველოს მართლმადიდებელი ეკლესია)
იოანე 20:19–26

და იყო მწუხრი იმ დღესა, კვირის პირველ დღეს, და კარნი დახშულნი იყვნენ, სადაც მოწაფენი იყვნენ შეკრებილნი იუდეველთა შიშისგან, მოვიდა იესო და დადგა მათ შორის და ჰრქუა მათ: მშვიდობა თქუენდა.
და ეს რომ თქვა, უჩვენა მათ ხელნი და გვერდი თვისი. და გაიხარეს მოწაფეებმა, იხილეს რა უფალი.
მაშინ კვლავ უთხრა მათ იესომ: მშვიდობა თქუენდა; როგორც მამამ მომავლინა მე, მეც თქვენ მოგავლინებთ.
და ეს რომ თქვა, შეუბერა მათ და უთხრა: მიიღეთ სული წმინდა.
ვისაც მიუტევებთ ცოდვებს, მიეტევებათ მათ; და ვისაც დაუკავებთ, დაუკავდებათ.
ხოლო თომა, ერთი თორმეტთაგანი, რომელსაც ეწოდებოდა ტყუპი, არ იყო მათთან, როცა მოვიდა იესო.
უთხრეს მას სხვა მოწაფეებმა: ვიხილეთ უფალი. ხოლო მან უთხრა მათ: თუ არ ვიხილავ მის ხელებზე ფრჩხილების ნიშანს და არ შევიტან ჩემს თითს ფრჩხილების ნიშანში და არ შევიტან ჩემს ხელს მის გვერდში, არ ვირწმუნებ.
და რვა დღის შემდეგ კვლავ იყვნენ შინ მისი მოწაფენი და თომაც მათთან. მოვიდა იესო, კარნი დახშულნი იყვნენ, დადგა მათ შორის და უთხრა: მშვიდობა თქუენდა.
 

Albanian (Orthodox Albanian Bible usage)
Gjoni 20:19–26

Dhe kur u bë mbrëmje në atë ditë, ditën e parë të javës, dhe dyert ishin të mbyllura ku ishin mbledhur dishepujt nga frika e judenjve, erdhi Jezusi dhe qëndroi në mes dhe u tha atyre: Paqe juve!
Dhe pasi tha këtë, u tregoi duart dhe brinjën e Tij. Atëherë dishepujt u gëzuan kur panë Zotin.
Dhe Jezusi u tha përsëri: Paqe juve! Sikurse më dërgoi Ati, ashtu ju dërgoj edhe unë juve.
Dhe pasi tha këtë, fryu mbi ta dhe u tha: Merrni Frymën e Shenjtë.
Kujt t’ia falni mëkatet, do t’u falen; kujt t’ia mbani, do t’u mbeten.
Por Thomai, një nga të dymbëdhjetët, i quajtur Binjaku, nuk ishte me ta kur erdhi Jezusi.
Dishepujt e tjerë i thoshin: E pamë Zotin. Por ai u tha: Nëse nuk shoh në duart e Tij shenjat e gozhdëve dhe nuk vë gishtin tim në shenjat e gozhdëve dhe nuk vë dorën time në brinjën e Tij, nuk do të besoj.
Dhe pas tetë ditësh, dishepujt e Tij ishin përsëri brenda dhe Thomai me ta. Erdhi Jezusi, kur dyert ishin të mbyllura, dhe qëndroi në mes dhe tha: Paqe juve!

Czech (Český ekumenický / Orthodox-used translation style)
Jan 20,19–26

Když byl večer onoho dne, prvního dne v týdnu, a dveře, kde byli učedníci shromážděni ze strachu před Židy, byly zavřeny, přišel Ježíš, postavil se doprostřed a řekl jim: Pokoj vám!

A když to řekl, ukázal jim ruce a svůj bok. Učedníci se zaradovali, když viděli Pána.
Ježíš jim znovu řekl: Pokoj vám! Jako Otec poslal mne, tak já posílám vás.
A když to řekl, dechl na ně a řekl jim: Přijměte Ducha Svatého.
Komu odpustíte hříchy, budou mu odpuštěny; komu je zadržíte, budou zadrženy.
Tomáš, jeden z dvanácti, zvaný Didymos, nebyl s nimi, když přišel Ježíš.
Ostatní učedníci mu říkali: Viděli jsme Pána. Ale on jim řekl: Jestliže neuvidím na jeho rukou jizvy po hřebech a nevložím svůj prst do jizev po hřebech a nevložím svou ruku do jeho boku, neuvěřím.
A po osmi dnech byli jeho učedníci opět uvnitř a Tomáš s nimi. Přišel Ježíš, když byly dveře zavřeny, postavil se doprostřed a řekl: Pokoj vám!

Slovak (Orthodox-used / liturgical style)
Ján 20,19–26

Keď bol večer toho prvého dňa v týždni a dvere, kde boli učeníci zhromaždení zo strachu pred Židmi, boli zavreté, prišiel Ježiš, postavil sa doprostred a povedal im: Pokoj vám!
A keď to povedal, ukázal im ruky a svoj bok. Učeníci sa zaradovali, keď videli Pána.
Ježiš im znova povedal: Pokoj vám! Ako mňa poslal Otec, aj ja posielam vás.
A keď to povedal, dýchol na nich a povedal im: Prijmite Ducha Svätého.
Komu odpustíte hriechy, budú mu odpustené; komu ich zadržíte, budú zadržané.
Tomáš, jeden z dvanástich, zvaný Didymus, nebol s nimi, keď prišiel Ježiš.
Ostatní učeníci mu hovorili: Videli sme Pána. Ale on im povedal: Ak neuvidím na jeho rukách stopy po klincoch a nevložím svoj prst do stôp po klincoch a nevložím svoju ruku do jeho boku, neuverím.
A po ôsmich dňoch boli jeho učeníci znova vnútri a Tomáš s nimi. Prišiel Ježiš, keď boli dvere zatvorené, postavil sa doprostred a povedal: Pokoj vám!

The Meaning of the Passage

This Gospel takes place on the evening of the Resurrection:

“Peace be with you.” (John 20:19)

The disciples are gathered in fear, behind closed doors. Yet Christ appears among them not as a ghost, but in His glorified body. His greeting, “Peace be with you,” is not merely comforting, it is transformative. It signals reconciliation between God and humanity.

Christ then shows His wounds, proving that the Crucified One is truly the Risen One.

The Gift of the Holy Spirit

One of the most profound moments in this passage is when Christ breathes on the disciples:

“Receive the Holy Spirit.” (John 20:22)

This act recalls the creation of Adam, when God breathed life into humanity. Here, the Risen Christ inaugurates a new creation—restoring and renewing mankind.

He also grants the apostles authority:

“If you forgive the sins of any, they are forgiven…” (John 20:23)

This becomes the foundation of the Church’s sacramental life.

The Absence of Thomas

Thomas is not present during this first appearance. His absence becomes spiritually significant, he represents all who struggle with doubt.

When told of the Resurrection, Thomas responds:

“Unless I see… I will not believe.” (John 20:25)

This honest doubt sets the stage for the next encounter (read the following Sunday), where faith is deepened through experience.

Why It Is Called the “Second Resurrection Gospel” ?

This Gospel reading done in multiple languages during Easter Monday services, is very adequate in international Church communities such as Orthodox Church pariches in Western Europe and America where, there are church members from virtually every nationality. 
Those reading is conduceted in Church Pariches by people whos native language is the language of reading or by anyone in the Church community that can speak or read the language. Thus the Church assemblyy shows clearly to the World:

1. The universality of the Resurrection for All Mankind and a reference to the Primal Language of Edem which in New Testamental times after Christ is the Language of Love and virtues as given by Christ.
2. The spreading of the Gospel to all nations (for which the apostles and every Christian has been called by the Saviour
The unity of the Church across cultures and tongues
3. The unity of the Church across cultures and tongues and the one saving truth that if practiced as prescribed will lead humanity and each individual to Christs faith and salvation.

Closing words
 

Hopefully this article was interseting for tech guys and some diversity from the boredom of tech stuff. I hope it shed some light love, faith, hope and peace and understanding for anyone who searches for the Truth.

I will close it with the Great and glorious and spiritually rich Paschal Sermon of Saint John Crysostom, that is being red on the Easter Service (at some Churches it is practice to read this sermon over the first three days Church services of Pasche).

The Catechetical Sermon of St. John Chrysostom reading Matins of Pascha.

The_Descent-of-Jesus-Christ-in-Hades-to-save-all-in-Hell-saint-Ekaterina-monastery-from-years-around-1500s

The descent to Hades of Christ – Saint Ekaterina Monastery ancient of Resurrection

If any man be devout and love God, let him enjoy this fair and radiant triumphal feast.
If any man be a wise servant, let him rejoicing enter into the joy of his Lord.
If any have labored long in fasting, let him now receive his recompense.
If any have wrought from the first hour, let him today receive his just reward.
If any have come at the third hour, let him with thankfulness keep the feast.
If any have arrived at the sixth hour, let him have no misgivings; because he shall in nowise be deprived thereof.
If any have delayed until the ninth hour, let him draw near, fearing nothing.
If any have tarried even until the eleventh hour, let him, also, be not alarmed at his tardiness; for the Lord, who is jealous of his honor, will accept the last even as the first; He gives rest unto him who comes at the eleventh hour, even as unto him who has wrought from the first hour.

And He shows mercy upon the last, and cares for the first; and to the one He gives, and upon the other He bestows gifts.
And He both accepts the deeds, and welcomes the intention, and honors the acts and praises the offering.
Wherefore, enter you all into the joy of your Lord; and receive your reward, both the first, and likewise the second.
You rich and poor together, hold high festival. You sober and you heedless, honor the day.
Rejoice today, both you who have fasted and you who have disregarded the fast.
The table is full-laden; feast ye all sumptuously.
The calf is fatted; let no one go hungry away.

Enjoy ye all the feast of faith: Receive ye all the riches of loving-kindness.
Let no one bewail his poverty, for the universal kingdom has been revealed.
Let no one weep for his iniquities, for pardon has shown forth from the grave.
Let no one fear death, for the Savior’s death has set us free.
He that was held prisoner of it has annihilated it. By descending into Hell, He made Hell captive.
He embittered it when it tasted of His flesh.
And Isaiah, foretelling this, did cry: Hell, said he, was embittered, when it encountered Thee in the lower regions.
It was embittered, for it was abolished. It was embittered, for it was mocked.
It was embittered, for it was slain. It was embittered, for it was overthrown.
It was embittered, for it was fettered in chains.
It took a body, and met God face to face.
It took earth, and encountered Heaven.
It took that which was seen, and fell upon the unseen.

O Death, where is your sting? O Hell, where is your victory?
Christ is risen, and you are overthrown.
Christ is risen, and the demons are fallen.
Christ is risen, and the angels rejoice.
Christ is risen, and life reigns.
Christ is risen, and not one dead remains in the grave.
For Christ, being risen from the dead, is become the first fruits of those who have fallen asleep.
To Him be glory and dominion unto ages of ages.
Amen.

No Comments »

« Previous Post

How to Install and Use Grafana Loki on Linux for mupltiple server Log Metrics Monitoring


March 31st, 2026

how-to-install-and-use-grafana-loki-on-linux-for-log-metrics-monitoring-for-multiple-server-observability-logo
Grafana Loki has become a popular choice for log management on Linux systems, nowadays, because free software like under AGPLv3 licence, it’s lightweight, cost-efficient, and integrates seamlessly with modern observability stacks. Unlike traditional log systems, Loki focuses on indexing metadata (labels) instead of full log content, which makes it especially attractive for Linux environments where logs can grow quickly.

Grafana Loki can be used to create fully featured logging stack. It has a small index and highly compressed chunks which simplifies the operation and significantly lowers the Storage expense of it.
Unlike other logging systems, Loki is built around the idea of only indexing metadata about your logs labels (just like Prometheus labels).
Log data itself is then compressed and stored in chunks in object stores such as Amazon Simple Storage Service (S3) or Google Cloud Storage (GCS), or even locally on the filesystem.

In this article will give you some real-world, practical usage of Loki on Linux, from its setup from zero to day-to-day use workflows.

Reasons why to use Loki on Linux ?

Linux systems generate logs mainly in /var/log but often used extra installed Apps tend to log in different locations for easier log distinguishment, e.g.
logs location might lack a good structure (be everywhere) :

Some common example locations, where logs are stored

  • /var/log/syslog
  • /var/log/auth.log
  • Application logs (/opt/app/logs/*.log)
  • Container logs, are kept within respective container ( Docker /  PodMan Kubernetes )

Sonner or later if you have to manage a large infrastructure of servers you end up, it is pretty easy to end up in a log mess.

This is exaclty where Loki helps you solve:

  • Centralize logs from multiple machines (within Grafana)
  • Search logs efficiently using log craeted labels
  • Correlate logs with metrics in Grafana

Loki Architecture Overview


loki-use-stack-chain-diagram-from-cloud-to-grafana

A typical Loki setup on Linux has 3 components:

  1. Loki server -> stores and queries logs
  2. Promtail -> collects logs from the around the system
  3. Grafana -> Use it to visualizes and queries logs

Promtail acts like a lightweight agent that tails log files and sends them to Loki.

I. Installing Loki on Linux

1. Download Loki

$ cd /usr/local/src
$ wget https://github.com/grafana/loki/releases/latest/download/loki-linux-amd64
$ chmod +x loki-linux-amd64
# mv loki-linux-amd64 /usr/local/bin/loki

2. Create a simple config like

auth_enabled: false

server:
  http_listen_port: 3100

ingester:
  lifecycler:
    address: 127.0.0.1
  chunk_idle_period: 5m

schema_config:
  configs:
    – from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  filesystem:
    directory: /var/lib/loki/chunks

3. Run Loki

# loki -config.file=loki.yaml


Hopefully if all is okay with loki.yaml config the service will start.

a. Installing Promtail (Log Collection)

Example  config (to modify to your preferences):

scrape_configs:
  – job_name: linux-logs
    static_configs:
      – targets:
          – localhost
        labels:
          job: syslog
          host: my-linux-server
          __path__: /var/log/*.log

This collects all logs in /var/log/ and labels them.

b. Run Promtail

# promtail -config.file=promtail.yaml

! Note that loki and promtail it is run as root (to have permissions to files which will be processed). This is not the best practice, so for security reasons,
if you have the necessery storage move out the files to a central log aggregator directory with a script set a unprevileged non-root user for it and run the services with those user.

c. Run loki / promtail as non-root user:

Once tested it runs, it is good idea to run two tools with non-root user, i.e.:
Run promtail as a dedicated user (e.g., promtail).

Add that user to groups like:

adm (for /var/log)

systemd-journal (for journal logs)
Adjust file permissions if needed

# useradd –system –no-create-home promtail
# usermod -aG adm promtail

$ loki -config.file=loki.yaml
$ promtail -config.file=promtail.yaml

II. Practical Use Cases of Loki on Linux

1. System Troubleshooting

One good use of Loki is to Search for errors in syslog:

{job="syslog"} |= "error"

By this you can Quickly diagnose:

  • Boot issues
  • Service failures
  • Kernel errors

2. SSH Login Monitoring

Track login attempts from /var/log/auth.log for many VM hosts:

{job="syslog"} |= "sshd"

You can detect:

  • Failed login attempts
  • Brute-force attacks
  • Unauthorized access

3. Application Debugging (look for exceptions)

If your app logs to /var/log/app.log and you App running it, to get a view on java thrown exceptions:

{job="app"} |= "exception"

This use case can Help developers to:

  • Trace bugs
  • Monitor runtime issues
  • Correlate logs with deployments

4. Multi-Server Log Aggregation

Once you run Promtail on multiple Linux servers:

labels:
  host: server1

Then you can do query to extract collected data for each one if it:

{job="syslog", host=~"server1|server2"}

This makes multiple machines behave like one unified log source.

5. Log-Based Metrics

You can extract metrics from logs:

count_over_time({job="syslog"} |= "error" [5m])

Use this for:

  • Alerting
  • Error rate tracking
  • Incident detection

III. Using Grafana for Visualization

In Grafana, you can:

  • View logs in real time
  • Build dashboards
  • Create alerts based on log patterns

Example use would be:

Create Grafana Panel showing error rate per host and Alert when errors exceed a threshold.

loki-log-drill-down-sample-in-grafana

Good Practices on Loki use

1. Always Use Meaningful Labels

Example for Good label should contain as many descriptory parameters as possible:

labels:
  app: nginx
  env: prod
  virtualization: vmware
  type: Middleware
  service:: proxy
  Customer: customerA

Bad obscure label:

labels:
  request_id: 123456  


2. Avoid Too many Unique labels

Keep in mind Too many unique labels leads to poor performance !.

3. Rotate Logs Properly and optimize with Secure Loki Endpoint

Loki won't manage your internal logs, as it can well complement ( but not replaces ), on Server / VM traditional tools like journalctl / grep / logrotate. but just give you a better overview of what is inside of service spit logs based on easy to give criterias from Grafana.
You will still need usually at best scenario to  setup of a Central Logging Server (to store all Infrastucture logs).
Consider also that sending data from your logs with Loki, like with a zabbix client it is always a idea to have reverse proxy like NGINX or Haproxy to reduce Network bandwith and for better management centralization of the infra.

4. Secure Loki Endpoint

  • Use reverse proxy (NGINX)
  • Enable authentication in production

Closure Summary

On Linux, Grafana Loki can help when:

  • You have multiple servers
  • Logs are growing fast
  • You need centralized  and relatively easy observability

Loki has its downtimes too as processing the logs to really extract data hits a high CPU use. Running it on a multiple machines is useful,
especially if your machines has high unutilized CPU IDLE time and you want to make the log data collection per server based being so to say partially duplicated and indepdendent from centralized logging. .
For high scale infrastructure, however sysadmins prefer to use an ELK OpenSearch Stack or log databases such as:
VictoriaLogs. With having infrastrcture of 100 servers or so perhaps setting up with some Ansible automation Loki makes sense.
Loki is not meant to replace databases or full-text search engines, but great often for simple  log aggregation and analysis and of the simplistic tools available today.

No Comments »

« Previous Post

Automatically Re-plug all USB devices on system resume on Debian Linux using systemd


March 26th, 2026

automatically-replug-all-usb-devices-on-system-resume-on-Debian-Ubuntu-Linux
Lets say you’re like me and you have an old but gold USB device like USB joystick Maxfire G-08XU (i've described how to configure Joystick / Gamepad on Debian Ubuntu easily), an USB flash drive stick or even some obscure USB keyboard model, that are not among the most compatible device on earth for linux. The result is in device plug and Sleeping the system or Hibernating it for a while (when go to bed) you end up with USB device being undetected by the system. Once you recover the Laptop / PC from being in Sleep mode / hibernate, the device becomes undetected by system, even though, even though the Linux kernel recognizes in lsusb. That weirdity continues until you do the manual hard workaround, which is to manually unplug the device cable and replug it again.
Though Linux has advanced much with this stuff over last years still this problems can occur every now and then. Thanksfully there is a quick fix to that. You can create a small script that reloads all the USB devices on PC
want the script to run automatically after your Debian laptop wakes up from suspend/hibernate. On Linux, the way to do this is using systemd sleep hooks. Here’s how to do it properly by using a small script + systemd.

1. Create a systemd sleep script

Create a new directory and file: 

# mkdir -p /etc/systemd/system-sleep

# vim /etc/systemd/system-sleep/usb-replug.sh

Add this content: 

#!/bin/bash
# Only run on resume (wake up)
case "$1" in
    post)
        # Replace '1-3' with your USB bus-port ID
        echo '1-3' | tee /sys/bus/usb/drivers/usb/unbind
        sleep 2
        echo '1-3' | tee /sys/bus/usb/drivers/usb/bind
        ;;
esac



If


If you need script logging use instead this small script:

 

#!/bin/bash

case $1/$2 in
pre/*)
# before suspend: you can put commands here if needed
;;
post/*)
# after resume: run your USB replug commands
echo "$(date) – Running USB replug script" >> /var/log/usb-replug.log
# Example command: trigger USB rescan
for bus in /sys/bus/usb/devices/*/authorized; do
echo 0 | sudo tee $bus
echo 1 | sudo tee $bus
done
;;
esac

2. Make it executable and reload systemd services

# chmod +x /etc/systemd/system-sleep/usb-replug.sh

Once you’ve created the script in /etc/systemd/system-sleep/ and made it executable, systemd will automatically call it on suspend/resume.

To make sure everything is recognized, you can:

  1. Reload systemd units (optional but recommended) 

# systemctl daemon-reload

  1. Test it manually by suspending and resuming your machine 

# systemctl suspend

After resuming, your script should run automatically and you should see the missing devices that you had to physically unplug and plug back to normal.
Hooray ! 🙂

3. How it works (systemd respawn)

  • systemd runs scripts in /etc/systemd/system-sleep/ on suspend and resume.

  • $1 is either pre (before sleep) or post (after wake).

  • The script unbinds and rebinds your USB device right after the system resumes.

Tip: You can also use usbreset instead of unbind/bind if you prefer, just replace the echo lines with:

# usbreset /dev/bus/usb/001/005

Alternatively you can use one time a simple one liner script that does the job like this:
 

# cat replug_usbs_linux.sh
#!/bin/bash

# one liner script to replug all USB devices like you have physically replugged all USBs useful if for example some of USB devices stuck after linux computer sleep

# for example my old maxfire g-08 usb joystick does mess up and i have to physically replug it (to work around this i simply run this script

d=$(lsusb -t | grep -m1 'Driver=' | sed -E 's|.*Port ([0-9]+):.*Bus ([0-9]+).*|\2-\1|') && echo $d | sudo tee /sys/bus/usb/drivers/usb/unbind && sleep 2 && echo $d | sudo tee /sys/bus/usb/drivers/usb/bind

 

No Comments »

« Previous Post

Building a 10-Server FreeBSD Jail Cluster Running a LAMP (Linux / Apache / MySQL / Perl / PHP / Python) Stack


March 25th, 2026

building-freebsd-jails-cluster-running-linux-apache-10-cluster-high-availability-with-mariadb-perl-php-howto

Virtualization and workload isolation are foundational to modern infrastructure.
While most teams today default to container platforms like Docker and orchestration systems such as Kubernetes, an older and highly capable alternative exists in the form of jails from FreeBSD.

FreeBSD jails provide lightweight OS-level isolation, allowing multiple independent userland environments to run on a single host. Introduced long before containers became mainstream, jails were designed with a strong focus on security, simplicity, and performance.
Despite their maturity and robustness, they are less commonly used today, largely due to the rapid rise of container ecosystems and cloud-native tooling.

Choosing between jails and containers is not simply a matter of “old vs new,” but rather a trade-off between control and simplicity versus portability and ecosystem support.

Short Comparison of FreeBSD jails and Containers ( Pros and Cons )

Advantages of FreeBSD Jails

a. Strong, simple isolation

Jails provide a clear and tightly integrated security boundary within the FreeBSD kernel. Their design is straightforward, reducing the risk of misconfiguration compared to layered container security models.

freebsd_jails_infographic_diagram

b. High performance

Because jails operate very close to the base system, they deliver near-native performance with minimal overhead—especially beneficial for networking and I/O-heavy workloads.

c. Operational simplicity

There are fewer component moving parts (easier to maintain and debbug):

  • No separate container runtime
  • No image layers
  • No complex orchestration requirements

This makes jails appealing for stable, long-running systems.

d. Predictability and stability

FreeBSD’s conservative, design philosophy results in systems that are highly stable over long periods, that is ideal for infrastructure roles like: storage or networking.

Disadvantages of FreeBSD Jails

a. Limited portability

Not neceserry a huge disadvantage but still,
Jails are tied to FreeBSD. Unlike containers, they cannot be easily moved across different operating systems or cloud platforms.


b. Smaller ecosystem

FBSD Jails is not full equivallent to:

  • Container registries (like Docker Hub)
  • Massive orchestration ecosystems (similar things has to be done with scripts and customizations)
  • Broad third-party integrations

This can slow down a bit development and deployment workflows. Though for a matured Applications that are once well tuned with jails that can be not a real probblem.

Note that though a con, this can also be a pros, as once you tune up an App for it becomes easier to maintain.

c. Less automation tooling

While tools exist, they are not as standardized or widely adopted as container-based CI/CD pipelines.

d. Harder to find people for it
 

Most developers and DevOps engineers are trained in container technologies, making hiring and collaboration easier in container-based environments. However for senior hard core sysadmins and system engineers that could be also advantage as not so many people have an indepth insight with both freebsd and fbsd jails.

This guide walks through a practical, production-style setup: 10 FreeBSD servers, each running isolated jails that host a classic LAMP stack (Linux, here replaced by FreeBSD, Apache, MySQL/MariaDB, PHP).
However still the use of companies or individuals who choose freebsd jails aim to better focus is on repeatability, clean architecture, and operational sanity, not just getting it to run once.

Architecture Overview of sample FBSD Cluster

Our Goal:

  • 10 physical or virtual servers
  • Each server runs multiple jails
  • Each jail runs a LAMP app instance
  • Load balancing across nodes (to have a High Availability Cluster like setup)

Host Setup:

  • 2 × load balancer nodes (nginx or HAProxy)
  • 6 × application nodes (Apache + PHP in jails)
  • 2 × database nodes (MariaDB primary/replica)

All systems run FreeBSD, using native jails for isolation.

1. Base FreeBSD Installation (All 10 Servers)

Install FreeBSD on each machine (minimal install is fine).

Update system:

# freebsd-update fetch install
# pkg update && pkg upgrade -y

Install base tools:

# pkg install -y sudo vim bash git

2. Install Jail Management tool (iocage)

We’ll use iocage, a modern jail manager.

# pkg install -y iocage
# sysrc iocage_enable="YES"
# service iocage start

Activate ZFS (recommended):

# zpool create zroot /dev/da0

Initialize iocage:

# iocage activate zroot
# iocage fetch

3. Create a Reusable Jail Template

Instead of building each jail manually, create a golden template.

# iocage create -n lamp-template -r 13.2-RELEASE ip4_addr="vnet0|10.0.0.10/24" boot=off
# iocage start lamp-template
# iocage console lamp-template

4. Install LAMP Stack Inside the Jail

Inside the jail:

4.1. Install Apache

# pkg install -y apache24
# sysrc apache24_enable="YES"

4.2. Install MariaDB

# pkg install -y mariadb106-server
# sysrc mysql_enable="YES"

Initialize DB:

service mysql-server start
mysql_secure_installation

4.3. Install PHP pre-compiled ports

# pkg install -y php82 php82-mysqli php82-mbstring php82-opcache


Configure Apache to use PHP:

# echo 'LoadModule php_module libexec/apache24/libphp.so' >> /usr/local/etc/apache24/httpd.conf
# echo 'AddType application/x-httpd-php .php' >> /usr/local/etc/apache24/httpd.conf

5. Test LAMP Stack works OK

Create a test file:

# echo "<?php phpinfo(); ?>" > /usr/local/www/apache24/data/index.php

Start services:

service apache24 start

Visit the jail IP and confirm PHP (page output) works in Firefox / Chrome Browser.

6. Convert Template into Clones

Stop Jail and snapshot:

iocage stop lamp-template
iocage snapshot lamp-template@base

Clone for production:

iocage clone lamp-template -n app01 ip4_addr="vnet0|10.0.0.21/24"
iocage clone lamp-template -n app02 ip4_addr="vnet0|10.0.0.22/24"

Repeat across servers and once working create a small shell script to run as a cron job to create backups automated.

Each server might run 5 up to 20 jails depending on resources.

7. Networking Between Jails

Use VNET for proper isolation:

Enable bridge on host:

# ifconfig bridge0 create
# ifconfig bridge0 addm em0 up

Assign jail interfaces automatically via iocage.

8.  Load Balancing Layer

On 2 dedicated nodes, install nginx:

# pkg install -y nginx
# sysrc nginx_enable="YES"

Example config:

http {
    upstream backend {
        server 10.0.0.21;
        server 10.0.0.22;
        server 10.0.1.21;
        server 10.0.1.22;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://backend;
        }
    }
}

9. Database Strategy

You have few options to choose from:

a. Use Centralized DB

  • Dedicated DB jails on 2 nodes
  • Primary + replica

b. Use Per-node DB (simpler)

  • Each jail has its own MariaDB
  • Use app-level replication if needed

10. Automation Across 10 Servers

Use tools like:

  • Ansible
  • SSH scripts
  • ZFS replication

Example (simple parallel execution loop) or use a set of scripts to handle updating with some Ansible Playbooks or Puppet:

# for host in server{1..10}; do
  ssh $host "pkg update"
done

Few more Operational Tips to consider

a. Tune up setup / Do Resource management

  • Limit jail CPU/memory using rctl
  • Avoid overcommitting RAM

b. Use Centralized Logging

c. Do regular jail Backups

  • Use ZFS snapshots to backup each of the Jails:

# zfs snapshot zroot/iocage/jails/app01@backup
…

d. Tighten Security

  • Disable root SSH
  • Use PF firewall on host
  • Keep jails minimal

e. Do a Further Scaling Strategy

  • Add more servers -> replicate template
  • Add more jails -> clone snapshots
  • Scale horizontally via load balancer

Summary and Last Thoughts

When Choose FBSD Jails and when Containers

  • Use jails when you control the infrastructure, need maximum efficiency, and value simplicity (e.g., appliances, CDNs, storage systems).
  • Use containers when portability, scalability, and integration with modern DevOps workflows are critical.

This setup plays to the strengths of FreeBSD jails:

1. Performance: near-native speed
2.Isolation: strong and predictable
3. Simplicity: fewer layers than container stacks

FreeBSD jails remain a powerful and efficient isolation mechanism, particularly well-suited for controlled, performance-sensitive environments. Containers, however, dominate in modern application deployment due to their flexibility and ecosystem. The choice ultimately depends on whether you prioritize system-level control or platform-level convenience.

You won’t get the ecosystem of tools like Docker or Kubernetes, but you gain control, stability, and efficiency, which is exactly why companies like Netflix still rely on this model in critical infrastructure.

 

No Comments »

« Previous Post