DEV Community: Mr Vi

Secure SSH Monitoring with Real-time Telegram Alerts

Mr Vi — Thu, 02 Oct 2025 06:39:18 +0000

A comprehensive guide to setting up automated SSH connection monitoring with Telegram notifications for enhanced server security.

🚨 The Problem

As a system administrator, you need to know immediately when someone connects to your server via SSH. Whether it's a legitimate user or a potential security threat, real-time awareness is crucial for maintaining server security.

Traditional approaches like checking logs manually or using basic monitoring tools often fall short because they:

❌ Don't provide real-time alerts
❌ Lack user identification details
❌ Miss parallel connection attempts
❌ Don't distinguish between different connection types

💡 The Solution: SSH Alert

SSH Alert is a robust, open-source solution that provides:

🔐 Maximum user identification - IP address, key fingerprint, user comments
📱 Real-time Telegram notifications - Instant alerts with detailed information
🛡️ Smart rate limiting - Prevents notification spam during parallel sessions
⚙️ Flexible configuration - Separate settings for different connection types
🔄 Automatic retry logic - Handles network failures gracefully
📊 Comprehensive logging - Detailed logs with optional JSON format

🚀 Quick Start

Installation

# Clone and install
git clone https://github.com/B4DCATs/ssh-login-alert
cd ssh-login-alert
sudo ./install.sh

Basic Configuration

Edit /etc/ssh-alert/config.conf:

# Telegram Configuration
TELEGRAM_BOT_TOKEN="your_bot_token_here"
TELEGRAM_CHAT_ID="your_chat_id_here"

# Server Information
SERVER_NAME="production-server"
SERVER_DOMAIN="example.com"

# Notification Settings
NOTIFY_INTERACTIVE_SESSIONS=true
NOTIFY_TUNNELS=false
DISABLE_NOTIFICATION_SOUND_FOR_TUNNELS=true

# Rate Limiting (seconds)
RATE_LIMIT_PER_IP=300
RATE_LIMIT_PER_KEY=60

🔧 Advanced Features

1. Enhanced User Identification

Configure authorized_keys for maximum user identification:

# Add user identification to SSH keys
environment="SSH_USER=alice@company.com" ssh-rsa AAAAB3NzaC1yc2E... alice@laptop

2. CI/CD Pipeline Exclusions

Exclude automated connections from notifications:

# Add exclusions for automated systems
sudo ./manage-exclusions.sh add "pipeline@ci"
sudo ./manage-exclusions.sh add "deploy@automation"
sudo ./manage-exclusions.sh add "monitoring@system"

3. Smart Notification Types

SSH Alert distinguishes between connection types:

Interactive Shell - Full terminal access (with sound notification)
SSH Tunnel - Port forwarding (silent notification)
Command Execution - Remote command execution (configurable)

4. Comprehensive Logging

# View real-time logs
sudo tail -f /var/log/ssh-alert.log

# Enable JSON logging for monitoring systems
echo 'JSON_LOGGING=true' | sudo tee -a /etc/ssh-alert/config.conf

📱 Setting Up Telegram Bot

Step 1: Create Bot

Message @BotFather on Telegram
Send /newbot
Follow the instructions to create your bot
Save the bot token

Step 2: Get Chat ID

Add your bot to a chat or send it a message
Visit: https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates
Find your chat.id in the response

🛡️ Security Best Practices

1. Secure Configuration

# Restrict access to configuration
sudo chmod 600 /etc/ssh-alert/config.conf
sudo chown root:root /etc/ssh-alert/config.conf

2. Firewall Configuration

# Allow SSH only from trusted networks
sudo ufw allow from 192.168.1.0/24 to any port 22
sudo ufw deny 22

3. SSH Hardening

# Disable password authentication
sudo nano /etc/ssh/sshd_config
# Set: PasswordAuthentication no
sudo systemctl restart sshd

📊 Monitoring and Maintenance

System Health Checks

# Check system status
sudo systemctl status ssh-alert 2>/dev/null || echo "Service not installed"

# View active connections
sudo ss -tnp | grep sshd

# Check recent notifications
sudo grep "SSH alert sent" /var/log/ssh-alert.log | tail -5

Log Rotation

SSH Alert automatically configures log rotation:

# Check rotation status
sudo ./check-log-rotation.sh status

# Test rotation configuration
sudo ./check-log-rotation.sh test

# Force rotation
sudo ./check-log-rotation.sh rotate

🔍 Troubleshooting

Common Issues

1. Notifications not arriving:

# Check configuration
sudo grep -E "TELEGRAM_BOT_TOKEN|TELEGRAM_CHAT_ID" /etc/ssh-alert/config.conf

# Check logs
sudo tail -f /var/log/ssh-alert.log

2. Script not starting:

# Check permissions
ls -la /opt/ssh-alert/ssh-alert-enhanced.sh

# Check syntax
bash -n /opt/ssh-alert/ssh-alert-enhanced.sh

3. Python errors:

# Check Python version
python3 --version

# Test parser
python3 /opt/ssh-alert/key-parser.py get-info

📈 Example Notification

Here's what you'll receive in Telegram:

🔐 SSH Login Alert:
Host IP: 203.0.113.1 / 192.168.1.100
Host: production-server.example.com
Person: alice@company.com
IP: 198.51.100.50
Type: Interactive shell
Key: SHA256:abcd1234...
Time: 2024-01-15 14:30:25 UTC

🎯 Use Cases

1. Production Server Monitoring

Real-time alerts for all SSH connections
Distinguish between legitimate users and potential threats
Track connection patterns and anomalies

2. Development Environment

Monitor team access to shared development servers
Track deployment activities
Ensure compliance with access policies

3. Security Incident Response

Immediate notification of unauthorized access attempts
Detailed connection information for forensic analysis
Integration with existing security monitoring systems

🔄 Updates and Maintenance

Automatic Updates

# Update from repository
git pull origin main
sudo ./install.sh

Manual Updates

# Create backup
sudo cp -r /opt/ssh-alert /opt/ssh-alert.backup
sudo cp /etc/ssh-alert/config.conf /etc/ssh-alert/config.conf.backup

# Update files
sudo cp ssh-alert-enhanced.sh /opt/ssh-alert/
sudo cp key-parser.py /opt/ssh-alert/

🗑️ Uninstallation

# Complete removal
sudo /opt/ssh-alert/uninstall.sh

🤝 Contributing

We welcome contributions! The project is open source and actively maintained.

Fork the repository
Create a feature branch
Make your changes
Submit a pull request

📚 Resources

GitHub Repository: https://github.com/B4DCATs/ssh-login-alert
Documentation: Complete setup guide in README
Issues: Report bugs or request features
License: MIT

🎉 Conclusion

SSH Alert provides a robust, easy-to-use solution for SSH connection monitoring. With its real-time Telegram notifications, flexible configuration, and comprehensive logging, it's an essential tool for any system administrator concerned with server security.

The combination of detailed user identification, smart rate limiting, and support for automated systems makes it suitable for both small teams and large enterprise environments.

Ready to enhance your server security? Give SSH Alert a try and never miss an SSH connection again!

Have you implemented SSH monitoring in your infrastructure? Share your experiences and tips in the comments below! 🚀

Руководство Python-разработчика по управлению фоновыми процессами

Mr Vi — Mon, 29 Sep 2025 17:22:37 +0000

Как Python-разработчик, вы наверняка сталкивались с такой ситуацией: вы создали отличного бота, API или скрипт для обработки данных, но поддерживать его работу 24/7 — это кошмар. SSH-сессии обрываются, скрипты падают, серверы перезагружаются, и ваша тщательно продуманная автоматизация внезапно оказывается недоступной.

В этом подробном руководстве мы рассмотрим различные подходы к запуску Python-приложений в фоновом режиме — от простых решений для разработки до готовых к продакшену систем управления процессами.

Проблема с "просто запуском Python"

При локальной разработке вы запускаете скрипты так:

python my_awesome_bot.py

Но в продакшене этот подход не работает, потому что:

Разрывы SSH-соединений убивают ваш процесс
Падения скриптов требуют ручного вмешательства
Перезагрузки сервера теряют все запущенные процессы
Управление несколькими ботами становится хаотичным
Нет видимости того, что действительно работает

Давайте исправим это с помощью правильного управления процессами.

Метод 1: Screen — решение для разработки

Screen идеально подходит для разработки и тестирования. Он создает постоянные терминальные сессии, которые переживают разрывы SSH-соединений.

Начало работы с Screen

# Установка screen
sudo apt install screen  # Ubuntu/Debian
sudo yum install screen  # CentOS/RHEL

# Запуск новой сессии
screen

# Активация виртуального окружения
source ./venv/bin/activate

# Запуск скрипта
python my_bot.py

# Отключение (Ctrl+A, затем D)
# Ваш скрипт продолжает работать!

Управление сессиями Screen

# Список всех сессий
screen -ls

# Подключение к сессии
screen -r session_name

# Завершение сессии (изнутри screen)
# Ctrl+A, затем K

Когда использовать Screen:

✅ Разработка и тестирование
✅ Быстрые одноразовые скрипты
✅ Когда нужен доступ к терминалу

Ограничения:

❌ Нет автоматического перезапуска при падениях
❌ Ручное управление процессами
❌ Сессии могут потеряться при перезагрузке сервера
❌ Нет встроенного мониторинга

Метод 2: Systemd — подход системных сервисов

Systemd — это менеджер служб Linux, идеально подходящий для продакшен-сред, где нужны гарантированный запуск и возможности перезапуска.

Создание службы Systemd

Создайте файл службы:

sudo nano /etc/systemd/system/mybot.service

Добавьте эту конфигурацию:

[Unit]
Description=My Python Bot Service
After=network.target

[Service]
Type=idle
Restart=always
RestartSec=3
User=myuser
WorkingDirectory=/home/myuser/bot
ExecStart=/home/myuser/bot/venv/bin/python /home/myuser/bot/my_bot.py
Environment=PATH=/home/myuser/bot/venv/bin

[Install]
WantedBy=multi-user.target

Управление службой

# Перезагрузка конфигурации systemd
sudo systemctl daemon-reload

# Включение автозапуска при загрузке
sudo systemctl enable mybot.service

# Запуск службы
sudo systemctl start mybot.service

# Проверка статуса
sudo systemctl status mybot.service

# Просмотр логов
sudo journalctl -u mybot.service -f

# Остановка службы
sudo systemctl stop mybot.service

Когда использовать Systemd:

✅ Продакшен-серверы
✅ Критически важные службы, которые должны пережить перезагрузки
✅ Системная интеграция
✅ Когда нужен детальный контроль

Ограничения:

❌ Требует root-доступа
❌ Сложная конфигурация
❌ Системное управление
❌ Нет встроенного мониторинга процессов

Метод 3: Современные менеджеры процессов — Python-путь

Для Python-разработчиков есть лучший способ: Pyker — менеджер процессов, созданный специально для Python-приложений.

Почему Pyker?

Pyker сочетает простоту screen с мощностью systemd, но разработан специально для Python-воркфлоу:

Python-нативный: Создан для Python-разработчиков, Python-разработчиками
Поддержка виртуальных окружений: Нативная интеграция с venv/conda
Нулевая конфигурация: Работает из коробки
Красивый мониторинг: Таблицы процессов в реальном времени
Установка в пользовательском пространстве: Не требует root-доступа

Установка

# Установка одной командой
curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.sh | bash

# Или с Python-установщиком
curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.py | python3

# Ручная установка
git clone https://github.com/mrvi0/pyker.git
cd pyker
python3 install.py

Базовое использование

# Запуск простого скрипта
pyker start mybot my_bot.py

# Запуск с виртуальным окружением
pyker start webapp app.py --venv ./venv

# Список всех процессов
pyker list

# Просмотр логов в реальном времени
pyker logs mybot -f

# Получение детальной информации о процессе
pyker info mybot

# Перезапуск процесса
pyker restart mybot

# Остановка процесса
pyker stop mybot

Продвинутые возможности

Автоперезапуск при падениях:

pyker start critical-service app.py --auto-restart

Поддержка виртуальных окружений:

# Работает с любыми Python-окружениями
pyker start ml-worker train.py --venv /path/to/conda/envs/pytorch
pyker start webapp app.py --venv ./venv
pyker start data-processor process.py --venv /home/user/projects/venv

Мониторинг процессов:

pyker list

Показывает красивую, адаптивную таблицу с:

Статусом процесса (✓ работает, ✗ остановлен, ⚠ ошибка)
Использованием CPU и памяти в реальном времени
Временем запуска/остановки
Информацией о виртуальном окружении
Путями к скриптам

Логи в реальном времени:

pyker logs mybot -f        # Следование логам в реальном времени
pyker logs mybot -n 100    # Показать последние 100 строк

Детальная информация о процессе:

pyker info mybot

Показывает исчерпывающую информацию, включая:

Путь к виртуальному окружению и исполняемому файлу Python
Использование ресурсов (CPU, память)
Информацию о времени выполнения
Расположение файла логов
Статус автоперезапуска

Автодополнение:

pyker <TAB>                # Показывает доступные команды
pyker stop <TAB>           # Дополняет именами запущенных процессов
pyker start app script.py --<TAB>  # Показывает --venv, --auto-restart

Реальные примеры

Управление Discord-ботами

# Традиционный подход с screen
screen
source ./venv/bin/activate
python discord_bot.py
# Ctrl+A, D

# С Pyker
pyker start discord-bot discord_bot.py --venv ./venv --auto-restart
pyker logs discord-bot -f

Развертывание веб-API

# С systemd (сложная настройка)
sudo nano /etc/systemd/system/api.service
# ... сложная конфигурация ...
sudo systemctl enable api.service

# С Pyker (просто)
pyker start api app.py --venv ./venv --auto-restart

Пайплайн обработки данных

# Несколько связанных процессов
pyker start scraper scraper.py --venv ./data-env
pyker start processor process_data.py --venv ./data-env  
pyker start uploader upload_to_s3.py --venv ./data-env

# Мониторинг всех процессов
pyker list

# Проверка конкретного процесса
pyker info scraper

Воркфлоу машинного обучения

# Обучение с правильным окружением
pyker start training train_model.py --venv /opt/conda/envs/pytorch --auto-restart

# Сервис инференса
pyker start inference inference_server.py --venv ./ml-env

# Предобработка данных
pyker start preprocess preprocess_data.py --venv ./data-env

Сравнение: выбор правильного метода

Метод	Сложность	Автоперезапуск	Вирт. окружения	Мониторинг	Лучше всего для
Screen	Низкая	❌	Ручной	Базовый	Разработка, тестирование
Systemd	Высокая	✅	Ручной	Системные логи	Продакшен-серверы
Pyker	Низкая	✅	Нативный	Встроенный	Python-приложения

Лучшие практики для продакшена

1. Всегда используйте виртуальные окружения

# Создание и активация окружения
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Запуск с Pyker
pyker start mybot my_bot.py --venv ./venv

2. Включайте автоперезапуск для критических служб

pyker start critical-service app.py --auto-restart

3. Реализуйте правильное логирование

import logging
import sys

# Настройка логирования
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('app.log')
    ]
)

logger = logging.getLogger(__name__)

def main():
    logger.info("Приложение запущено")
    try:
        # Логика вашего приложения
        pass
    except Exception as e:
        logger.error(f"Ошибка приложения: {e}")
        raise

if __name__ == "__main__":
    main()

4. Обрабатывайте корректные завершения

import signal
import sys
import logging

logger = logging.getLogger(__name__)

def signal_handler(sig, frame):
    logger.info("Получен сигнал завершения, очистка...")
    # Код очистки здесь
    sys.exit(0)

# Регистрация обработчиков сигналов
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

5. Мониторьте ваши процессы

# Регулярные проверки статуса
pyker list

# Мониторинг логов
pyker logs mybot -f

# Проверка системных ресурсов
htop

Решение типичных проблем

Процесс не запускается

# Сначала протестируйте скрипт вручную
python my_bot.py

# Проверьте логи Pyker
pyker logs mybot

# Проверьте информацию о процессе
pyker info mybot

Проблемы с виртуальными окружениями

# Убедитесь, что путь к venv существует
ls -la ./venv/bin/python

# Протестируйте с абсолютным путем
pyker start mybot my_bot.py --venv /полный/путь/к/venv

# Проверьте исполняемый файл Python
./venv/bin/python --version

Высокое использование ресурсов

# Мониторинг использования ресурсов
pyker list  # Показывает колонки CPU и памяти

# Проверка системных ресурсов
htop
top

# Завершение проблемных процессов
pyker stop process_name

Управление логами

# Просмотр файлов логов напрямую
ls -la ~/.pyker/logs/

# Очистка старых логов
rm ~/.pyker/logs/*.log.*

# Настройка ротации логов
nano ~/.pyker/config.json

Соображения безопасности

Права пользователей

# Запуск от имени пользователя без root
pyker start mybot my_bot.py --venv ./venv

# Проверка владельца процесса
ps aux | grep mybot

Переменные окружения

# Установка переменных окружения
export API_KEY="your-secret-key"
pyker start mybot my_bot.py --venv ./venv

Сетевая безопасность

# Привязка только к localhost
pyker start api app.py --venv ./venv
# Настройте ваше приложение для привязки к 127.0.0.1:8000

Заключение

Запуск Python-приложений в продакшене не должен быть сложным. Ключ в выборе правильного инструмента для ваших нужд:

Разработка/Тестирование: Используйте Screen для быстрого тестирования
Системные службы: Используйте Systemd для критически важных системных служб
Python-приложения: Используйте Pyker для современного управления Python-процессами

Pyker предлагает идеальный баланс простоты и мощности для Python-разработчиков. Он создан специально для Python-воркфлоу, нативно поддерживает виртуальные окружения и предоставляет красивый мониторинг без сложности systemd.

Лучшая часть? Вы можете начать просто и масштабироваться. Начните с Screen для разработки, затем переходите к Pyker для продакшена, и используйте Systemd только когда нужна глубокая системная интеграция.

Ваши Python-приложения заслуживают лучшего, чем ручные перезапуски и SSH-сессии. Выберите правильный инструмент, и пусть ваш код работает надежно 24/7.

Какой у вас опыт запуска Python-приложений в продакшене? Пробовали ли вы какие-либо из этих подходов? Поделитесь своими мыслями в комментариях ниже!

python #devops #processmanagement #automation #production #linux #systemd #backgroundprocesses

The Python Developer's Guide to Background Process Management

Mr Vi — Mon, 29 Sep 2025 17:19:12 +0000

As a Python developer, you've probably faced this scenario: you've built an amazing bot, API, or data processing script, but keeping it running 24/7 is a nightmare. SSH sessions disconnect, scripts crash, servers reboot, and suddenly your carefully crafted automation is offline.

In this comprehensive guide, we'll explore different approaches to running Python applications in the background, from simple development solutions to production-ready process management.

The Problem with "Just Running Python"

When you develop locally, you run scripts like this:

python my_awesome_bot.py

But in production, this approach fails because:

SSH disconnections kill your process
Script crashes require manual intervention
Server reboots lose all running processes
Managing multiple bots becomes chaotic
No visibility into what's actually running

Let's fix this with proper process management.

Method 1: Screen - The Development Solution

Screen is perfect for development and testing. It creates persistent terminal sessions that survive SSH disconnections.

Getting Started with Screen

# Install screen
sudo apt install screen  # Ubuntu/Debian
sudo yum install screen  # CentOS/RHEL

# Start a new session
screen

# Activate your virtual environment
source ./venv/bin/activate

# Run your script
python my_bot.py

# Detach (Ctrl+A, then D)
# Your script keeps running!

Managing Screen Sessions

# List all sessions
screen -ls

# Reattach to a session
screen -r session_name

# Kill a session (from within screen)
# Ctrl+A, then K

When to use Screen:

✅ Development and testing
✅ Quick one-off scripts
✅ When you need terminal access

Limitations:

❌ No automatic restart on crashes
❌ Manual process management
❌ Sessions can be lost on server reboot
❌ No built-in monitoring

Method 2: Systemd - The System Service Approach

Systemd is Linux's service manager, perfect for production environments where you need guaranteed startup and restart capabilities.

Creating a Systemd Service

Create a service file:

sudo nano /etc/systemd/system/mybot.service

Add this configuration:

[Unit]
Description=My Python Bot Service
After=network.target

[Service]
Type=idle
Restart=always
RestartSec=3
User=myuser
WorkingDirectory=/home/myuser/bot
ExecStart=/home/myuser/bot/venv/bin/python /home/myuser/bot/my_bot.py
Environment=PATH=/home/myuser/bot/venv/bin

[Install]
WantedBy=multi-user.target

Managing the Service

# Reload systemd configuration
sudo systemctl daemon-reload

# Enable auto-start on boot
sudo systemctl enable mybot.service

# Start the service
sudo systemctl start mybot.service

# Check status
sudo systemctl status mybot.service

# View logs
sudo journalctl -u mybot.service -f

# Stop the service
sudo systemctl stop mybot.service

When to use Systemd:

✅ Production servers
✅ Critical services that must survive reboots
✅ System-level integration
✅ When you need fine-grained control

Limitations:

❌ Requires root access
❌ Complex configuration
❌ System-level management
❌ No built-in process monitoring

Method 3: Modern Process Managers - The Python Way

For Python developers, there's a better way: Pyker - a process manager built specifically for Python applications.

Why Pyker?

Pyker combines the simplicity of screen with the power of systemd, but designed specifically for Python workflows:

Python-native: Built for Python developers, by Python developers
Virtual environment support: Native venv/conda integration
Zero configuration: Works out of the box
Beautiful monitoring: Real-time process tables
User-space installation: No root access required

Installation

# One-line installation
curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.sh | bash

# Or with Python installer
curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.py | python3

# Manual installation
git clone https://github.com/mrvi0/pyker.git
cd pyker
python3 install.py

Basic Usage

# Start a simple script
pyker start mybot my_bot.py

# Start with virtual environment
pyker start webapp app.py --venv ./venv

# List all processes
pyker list

# View logs in real-time
pyker logs mybot -f

# Get detailed process information
pyker info mybot

# Restart a process
pyker restart mybot

# Stop a process
pyker stop mybot

Advanced Features

Auto-restart on failure:

pyker start critical-service app.py --auto-restart

Virtual environment support:

# Works with any Python environment
pyker start ml-worker train.py --venv /path/to/conda/envs/pytorch
pyker start webapp app.py --venv ./venv
pyker start data-processor process.py --venv /home/user/projects/venv

Process monitoring:

pyker list

Shows a beautiful, adaptive table with:

Process status (✓ running, ✗ stopped, ⚠ error)
Real-time CPU and memory usage
Start/stop times
Virtual environment information
Script paths

Real-time logs:

pyker logs mybot -f        # Follow logs in real-time
pyker logs mybot -n 100    # Show last 100 lines

Detailed process information:

pyker info mybot

Shows comprehensive information including:

Virtual environment path and Python executable
Resource usage (CPU, memory)
Runtime information
Log file location
Auto-restart status

Tab completion:

pyker <TAB>                # Shows available commands
pyker stop <TAB>           # Completes with running process names
pyker start app script.py --<TAB>  # Shows --venv, --auto-restart

Real-World Examples

Discord Bot Management

# Traditional approach with screen
screen
source ./venv/bin/activate
python discord_bot.py
# Ctrl+A, D

# With Pyker
pyker start discord-bot discord_bot.py --venv ./venv --auto-restart
pyker logs discord-bot -f

Web API Deployment

# With systemd (complex setup)
sudo nano /etc/systemd/system/api.service
# ... complex configuration ...
sudo systemctl enable api.service

# With Pyker (simple)
pyker start api app.py --venv ./venv --auto-restart

Data Processing Pipeline

# Multiple related processes
pyker start scraper scraper.py --venv ./data-env
pyker start processor process_data.py --venv ./data-env  
pyker start uploader upload_to_s3.py --venv ./data-env

# Monitor all processes
pyker list

# Check specific process
pyker info scraper

Machine Learning Workflows

# Training with proper environment
pyker start training train_model.py --venv /opt/conda/envs/pytorch --auto-restart

# Inference service
pyker start inference inference_server.py --venv ./ml-env

# Data preprocessing
pyker start preprocess preprocess_data.py --venv ./data-env

Comparison: Choosing the Right Method

Method	Complexity	Auto-restart	Virtual Env	Monitoring	Best For
Screen	Low	❌	Manual	Basic	Development, testing
Systemd	High	✅	Manual	System logs	Production servers
Pyker	Low	✅	Native	Built-in	Python applications

Best Practices for Production

1. Always Use Virtual Environments

# Create and activate environment
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Run with Pyker
pyker start mybot my_bot.py --venv ./venv

2. Enable Auto-restart for Critical Services

pyker start critical-service app.py --auto-restart

3. Implement Proper Logging

import logging
import sys

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('app.log')
    ]
)

logger = logging.getLogger(__name__)

def main():
    logger.info("Application started")
    try:
        # Your application logic
        pass
    except Exception as e:
        logger.error(f"Application error: {e}")
        raise

if __name__ == "__main__":
    main()

4. Handle Graceful Shutdowns

import signal
import sys
import logging

logger = logging.getLogger(__name__)

def signal_handler(sig, frame):
    logger.info("Received shutdown signal, cleaning up...")
    # Cleanup code here
    sys.exit(0)

# Register signal handlers
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

5. Monitor Your Processes

# Regular status checks
pyker list

# Monitor logs
pyker logs mybot -f

# Check system resources
htop

Troubleshooting Common Issues

Process Won't Start

# Test the script manually first
python my_bot.py

# Check Pyker logs
pyker logs mybot

# Verify process information
pyker info mybot

Virtual Environment Issues

# Verify venv path exists
ls -la ./venv/bin/python

# Test with absolute path
pyker start mybot my_bot.py --venv /full/path/to/venv

# Check Python executable
./venv/bin/python --version

High Resource Usage

# Monitor resource usage
pyker list  # Shows CPU and memory columns

# Check system resources
htop
top

# Kill problematic processes
pyker stop process_name

Log Management

# View log files directly
ls -la ~/.pyker/logs/

# Clean old logs
rm ~/.pyker/logs/*.log.*

# Configure log rotation
nano ~/.pyker/config.json

Security Considerations

User Permissions

# Run as non-root user
pyker start mybot my_bot.py --venv ./venv

# Check process ownership
ps aux | grep mybot

Environment Variables

# Set environment variables
export API_KEY="your-secret-key"
pyker start mybot my_bot.py --venv ./venv

Network Security

# Bind to localhost only
pyker start api app.py --venv ./venv
# Configure your app to bind to 127.0.0.1:8000

Conclusion

Running Python applications in production doesn't have to be complicated. The key is choosing the right tool for your needs:

Development/Testing: Use Screen for quick testing
System Services: Use Systemd for critical system services
Python Applications: Use Pyker for modern Python process management

Pyker offers the perfect balance of simplicity and power for Python developers. It's designed specifically for Python workflows, supports virtual environments natively, and provides beautiful monitoring without the complexity of systemd.

The best part? You can start simple and scale up. Begin with Screen for development, then move to Pyker for production, and only use Systemd when you need deep system integration.

Your Python applications deserve better than manual restarts and SSH sessions. Choose the right tool, and let your code run reliably 24/7.

What's your experience with running Python applications in production? Have you tried any of these approaches? Share your thoughts in the comments below!

python #devops #processmanagement #automation #production #linux #systemd #backgroundprocesses

Monitoring OpenVPN with Prometheus and Grafana: A Complete Guide

Mr Vi — Sat, 27 Sep 2025 05:53:42 +0000

Why Monitor OpenVPN?

OpenVPN is one of the most popular VPN solutions, but monitoring VPN connections can be challenging. Without proper monitoring, you might not notice when clients are having connection issues, when traffic patterns change, or when your VPN server is under stress.

In this guide, we'll set up comprehensive monitoring for OpenVPN using Prometheus and Grafana, including:

Real-time client connection tracking
Traffic statistics and bandwidth monitoring
Security alerts and access control
Beautiful dashboards for visualization

The Challenge: OpenVPN Status Files

OpenVPN provides status information through text files, but these aren't designed for modern monitoring systems. The status files contain client information, traffic statistics, and connection details, but you need a way to:

Parse these files regularly
Convert the data to metrics format
Expose metrics to Prometheus
Visualize the data in Grafana

Solution: OpenVPN Prometheus Exporter

We'll use an open-source OpenVPN Prometheus Exporter that solves these challenges by:

Reading OpenVPN status files automatically
Converting data to Prometheus metrics format
Providing security features like IP-based access control
Including a ready-to-use Grafana dashboard

Step 1: Setting Up OpenVPN Server

First, ensure your OpenVPN server is configured to write status files. If you don't have OpenVPN set up yet, I recommend using the excellent openvpn-install script:

curl -O https://raw.githubusercontent.com/angristan/openvpn-install/master/openvpn-install.sh
chmod +x openvpn-install.sh
./openvpn-install.sh

Add this to your OpenVPN server configuration to enable status logging:

# Add to /etc/openvpn/server.conf
status /var/log/openvpn/status.log 30

The status file will be updated every 30 seconds with client information.

Step 2: Deploying the Exporter

The easiest way to deploy the exporter is using Docker:

# Download docker-compose.yml
curl -O https://raw.githubusercontent.com/B4DCATs/openvpn_exporter/main/docker-compose.yml

# Start the exporter
docker compose up -d

Or use the one-command setup script:

curl -sSL https://raw.githubusercontent.com/B4DCATs/openvpn_exporter/main/quick-start.sh | bash

The exporter will be available at http://localhost:9176/metrics.

Step 3: Security Configuration

For production environments, restrict metrics access to specific IPs:

# docker-compose.yml
environment:
  - ALLOWED_IPS=192.168.1.100,10.0.0.50,monitoring-server.local

This ensures only your monitoring infrastructure can access the metrics.

Step 4: Prometheus Configuration

Add the exporter to your Prometheus configuration:

# prometheus.yml
scrape_configs:
  - job_name: 'openvpn-exporter'
    static_configs:
      - targets: ['your-server:9176']
    scrape_interval: 30s
    metrics_path: /metrics

Step 5: Grafana Dashboard

Import the included dashboard for immediate visualization:

# Download the dashboard
curl -O https://raw.githubusercontent.com/B4DCATs/openvpn_exporter/main/dashboard.json

In Grafana:

Go to Dashboards → Import
Upload dashboard.json
Select your Prometheus datasource

The dashboard includes:

Client Statistics: Connected clients, traffic, connection times
Server Health: Server status and availability
Traffic Analysis: Bytes sent/received, top users
Security Monitoring: Access control alerts

Key Metrics to Monitor

Here are the most important metrics to track:

Client Connections

# Total connected clients
sum(openvpn_server_client_count)

# Clients by server
openvpn_server_client_count{instance="your-server"}

Traffic Analysis

# Top 5 clients by traffic
topk(5, openvpn_server_client_received_bytes_total + openvpn_server_client_sent_bytes_total)

# Traffic rate per client
rate(openvpn_server_client_received_bytes_total[5m])

Connection Duration

# How long clients have been connected
time() - openvpn_server_client_connection_time

Setting Up Alerts

Create alerts for critical events:

# alert.rules.yml
groups:
  - name: openvpn_alerts
    rules:
      - alert: OpenVPNServerDown
        expr: openvpn_up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "OpenVPN server is down"

      - alert: TooManyClients
        expr: openvpn_server_client_count > 100
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "Too many OpenVPN clients connected"

Advanced Configuration

Multiple OpenVPN Servers

Monitor multiple servers by updating the status paths:

export STATUS_PATHS="/var/log/openvpn/server1.status,/var/log/openvpn/server2.status"
docker compose up -d

Service Discovery

Use Prometheus file-based service discovery for dynamic monitoring:

# prometheus.yml
scrape_configs:
  - job_name: 'openvpn-exporter'
    file_sd_configs:
      - files:
          - 'openvpn-targets.json'

# openvpn-targets.json
[
  {
    "targets": ["openvpn-server-1:9176"],
    "labels": {
      "instance": "server-1",
      "environment": "production"
    }
  }
]

Complete Monitoring Stack

For a full monitoring setup, use the complete Docker Compose stack:

# Download complete stack
curl -O https://raw.githubusercontent.com/B4DCATs/openvpn_exporter/main/examples/config/docker-compose.full.yml

# Start monitoring stack
docker compose -f docker-compose.full.yml up -d

This includes:

OpenVPN Exporter
Prometheus
Grafana
Pre-configured dashboards and alerts

Access your monitoring:

Prometheus: http://localhost:9090
Grafana: http://localhost:3000 (admin/admin)

Troubleshooting Common Issues

Status File Not Found

# Find your OpenVPN status files
find /var/log -name "*openvpn*" -type f

# Common locations:
# /var/log/openvpn/status.log
# /var/log/openvpn/server.status

No Metrics Available

# Check exporter logs
docker logs openvpn-exporter

# Test metrics endpoint
curl -s http://localhost:9176/metrics | grep openvpn

Access Denied Errors

# Check ALLOWED_IPS configuration
docker logs openvpn-exporter | grep "Access denied"

# Test from allowed IP
curl -H "X-Forwarded-For: 192.168.1.100" http://localhost:9176/metrics

Best Practices

Security First: Always use IP restrictions in production
Regular Monitoring: Set up alerts for server downtime and unusual traffic
Capacity Planning: Monitor client counts and traffic trends
Backup Configuration: Keep your monitoring configuration in version control
Documentation: Document your monitoring setup and alert procedures

Conclusion

Monitoring OpenVPN with Prometheus and Grafana provides valuable insights into your VPN infrastructure. You'll be able to:

Track client connections and usage patterns
Monitor server health and performance
Detect security issues and unusual activity
Plan capacity based on traffic trends
Troubleshoot connection problems quickly

The OpenVPN Prometheus Exporter makes this setup straightforward with its security features, comprehensive dashboard, and easy deployment options.

Resources

OpenVPN Prometheus Exporter - The exporter we used
Prometheus Documentation - Learn more about Prometheus
Grafana Documentation - Grafana setup and configuration
OpenVPN Documentation - OpenVPN configuration

Start monitoring your OpenVPN infrastructure today and gain the visibility you need to ensure reliable VPN services for your users!

ConfWatch: The Configuration File Monitor That Actually Works

Mr Vi — Fri, 05 Sep 2025 18:28:32 +0000

The Problem Every Developer Faces

You know that feeling when you're debugging a server issue at 3 AM, and you realize you changed a config file last week but can't remember what you changed? Or when your colleague asks "what did you modify in the nginx config?" and you're staring at a file that looks completely different from what you remember?

I've been there. We've all been there.

Enter ConfWatch

ConfWatch is a simple, powerful tool that solves this exact problem. It's like having a time machine for your configuration files.

What It Does (In Plain English)

Tracks every change to your config files automatically
Shows you exactly what changed with beautiful diffs
Lets you go back in time to any previous version
Works in the background without you thinking about it
Has a web interface so you can see everything in a browser

Why I Built This

I was tired of:

Manually copying config files before making changes
Forgetting what I changed and when
Spending hours debugging issues caused by config changes
Not having a proper history of my server configurations

So I built ConfWatch to solve these problems once and for all.

How It Works (The Simple Version)

Install it - One command, done
Tell it which files to watch - Point it at your configs
Make changes normally - It watches in the background
See what changed - Check the web interface or CLI
Rollback if needed - One command to go back

Real-World Example

Let's say you're managing a web server:

# Install ConfWatch
curl -fsSL https://raw.githubusercontent.com/mrvi0/conf-watch/main/install.sh | bash

# Start monitoring your nginx config
confwatch snapshot /etc/nginx/nginx.conf

# Make some changes to nginx.conf
# ... edit the file ...

# See what changed
confwatch diff /etc/nginx/nginx.conf

# If something breaks, rollback
confwatch rollback /etc/nginx/nginx.conf abc1234

That's it. No complex setup, no learning curve.

Features That Actually Matter

Automatic Monitoring

Watches files for changes automatically
Creates snapshots when files are modified
No need to remember to backup before changes

Beautiful Web Interface

See all your files and their history
Click to see diffs between versions
One-click rollbacks
Works on any device with a browser

Command Line Power

Full CLI for automation and scripting
Integrates with your existing workflow
Works great in CI/CD pipelines

Smart Features

Only tracks actual changes (not just file touches)
Compresses old versions to save space
Handles multiple files simultaneously
Secure authentication for web interface

Why This Matters

For Developers

Never lose track of config changes again
Debug issues faster with complete change history
Collaborate better with team members
Reduce downtime from configuration mistakes

For DevOps

Maintain audit trails for compliance
Quickly rollback problematic changes
Monitor configuration drift across servers
Integrate with existing monitoring tools

For System Administrators

Keep track of server configuration changes
Quickly identify what changed before an outage
Maintain configuration backups automatically
Reduce human error in configuration management

The Technical Stuff (If You Care)

Built in Python with a clean, simple architecture
Uses Git under the hood for version control
Web interface built with Flask
Supports both manual and automatic snapshots
Works on Linux, macOS, and Windows
Lightweight and fast

Getting Started

The installation is literally one command:

curl -fsSL https://raw.githubusercontent.com/mrvi0/conf-watch/main/install.sh | bash

Then start monitoring your files:

confwatch snapshot /path/to/your/config

Open the web interface and you're done.

The Bottom Line

ConfWatch solves a real problem that every developer and system administrator faces. It's not another complex tool that requires a PhD to use. It's simple, it works, and it saves you time and headaches.

If you've ever spent hours debugging a configuration issue, or if you've ever wished you could could see what changed in a config file last week, give ConfWatch a try.

Your future self will thank you.

GitHub: https://github.com/mrvi0/conf-watch
Installation: curl -fsSL https://raw.githubusercontent.com/mrvi0/conf-watch/main/install.sh | bash

Have you tried ConfWatch? Let me know what you think in the comments below!

Pyker: A Modern PM2 Alternative for Python Developers

Mr Vi — Tue, 19 Aug 2025 00:09:00 +0000

Managing Python scripts in production can be a pain. You start a script, it crashes, you restart it manually, check logs by SSH-ing into servers... Sound familiar? While PM2 solved this for Node.js, Python developers have been stuck with systemd, screen sessions, or complex container setups.

Meet Pyker - a lightweight, user-friendly process manager built specifically for Python scripts.

🚀 What is Pyker?

Pyker is a command-line tool that lets you start, stop, monitor, and manage Python scripts as background processes. Think PM2, but designed from the ground up for Python with modern features like virtual environment support, adaptive terminal output, and zero-sudo installation.

# Start a Python script as a background process
pyker start mybot bot.py

# List all running processes
pyker list

# View real-time logs
pyker logs mybot -f

# Process still running after restart? ✅
pyker restart mybot

✨ Key Features

🐍 Virtual Environment Support - Works seamlessly with venv, conda, pipenv
📊 Beautiful Table Interface - Adaptive layout that fits your terminal
🔄 Auto-restart - Keep your scripts running even after crashes
📝 Centralized Logging - All process logs in one place with rotation
⌨️ Tab Completion - Smart autocompletion for commands and process names
🛠️ Simple Installation - No sudo required, installs in user space
🎯 Cross-platform - Linux, macOS, and Windows support

📦 Installation

One-line Installation

curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.sh | bash

Manual Installation

# Clone and install
git clone https://github.com/mrvi0/pyker.git
cd pyker
python3 install.py

No sudo required! Pyker installs in your user space (~/.local/bin) and automatically configures your PATH.

🐍 Virtual Environment Magic

One of Pyker's standout features is native virtual environment support. Just point to your venv, and Pyker handles the rest:

# Start with virtual environment
pyker start webapp app.py --venv ./venv

# Works with any environment type
pyker start ml-worker train.py --venv /path/to/conda/envs/pytorch

# Environment info is preserved across restarts
pyker restart webapp  # Still uses ./venv automatically

Pyker automatically detects Python executables in:

venv/bin/python (Linux/macOS)
venv/Scripts/python.exe (Windows)

📊 Process Monitoring Made Easy

The list command shows all your processes in a beautiful, adaptive table:

Status symbols make it instantly clear:

✅ Green checkmark - Running smoothly
❌ Red X - Stopped/crashed
⚠️ Yellow warning - High resource usage

🔧 Advanced Features

Detailed Process Information

pyker info mybot

Process Information: mybot
Status: ✓ Running
PID: 123456
Script: /home/user/bots/trading_bot.py
CPU Usage: 2.1%
Memory: 45.2 MB
Started: 2025-08-19 09:30:15
Virtual env: ./venv
Python executable: /home/user/project/venv/bin/python
Log file: /home/user/.pyker/logs/mybot.log
Auto restart: Yes

Smart Log Managemente

py real-time
pyt -ker logs mybot -ow lines last 100 linesot
pyker logs mybot are automatically rotated based on size, preventing disk space issues.

Tab Completion

Pyker includes intelligent tab completion:

pyker <TAB>          # Shows available commands
pyker stop <TAB>     # Completes with running process names
pyker logs bot<TAB>  # Completes process names
pyker start app script.py --<TAB>  # Shows --venv, --auto-restart

🛡️ Built for Reliability

Auto-restart on Failure

pyker start critical-service app.py --auto-restart

If your script crashes, Pyker automatically restarts it and logs the incident.

Safe Uninstallation

pyker uninstall

Pyker includes a built-in uninstall command that:

Shows exactly what will be removed
Stops all running processes with confirmation
Optionally preserves logs and configuration
Can be cancelled at any point

🎯 Real-world Use Cases

Web Developers:

pyker start api app.py --venv ./venv --auto-restart
pyker start worker celery_worker.py --venv ./venv

Data Scientists:

pyker start jupyter jupyter_server.py --venv ./ml-env
pyker start training train_model.py --venv /opt/conda/envs/pytorch

DevOps/Automation:

pyker start monitor system_monitor.py --auto-restart
pyker start backup backup_script.py --venv ./tools-env

Discord/Telegram Bots:

pyker start discord-bot bot.py --venv ./bot-env --auto-restart
pyker logs discord-bot -f  # Monitor bot activity

🔄 Migration from PM2

Coming from PM2? The transition is smooth:

PM2	Pyker	Notes
`pm2 start app.js`	`pyker start app app.py`	Similar syntax
`pm2 list`	`pyker list`	Enhanced table view
`pm2 logs app`	`pyker logs app -f`	Follow logs
`pm2 restart app`	`pyker restart app`	Preserves venv
`pm2 delete app`	`pyker delete app`	Clean removal

🚀 Why Choose Pyker?

Python-First Design - Built specifically for Python workflows
Modern UX - Beautiful, adaptive interface that fits any terminal
Zero Configuration - Works out of the box with sensible defaults
Virtual Environment Native - First-class venv support
Lightweight - Single Python file, minimal dependencies
User-Space Installation - No root access required
Cross-Platform - Same experience on Linux, macOS, Windows

🔮 What's Next?

Pyker is actively developed with upcoming features:

Web dashboard for remote monitoring
Integration with systemd for true service management
Docker container support
Process health checks and notifications
Configuration file support for complex setups

📥 Get Started Today

# Install Pyker
curl -fsSL https://raw.githubusercontent.com/mrvi0/pyker/main/install.sh | bash

# Start your first process
pyker start myapp app.py --venv ./venv

# Monitor it
pyker list
pyker logs myapp -f

🤝 Contributing

Pyker is open source and welcomes contributions! Whether it's bug reports, feature requests, or code contributions, check out our GitHub repository.

Made with ❤️ for Python developers who want simple, reliable process management.

Have you tried Pyker? Share your experience in the comments below!

ConfWatch v3.0.0: Configuration File Monitoring with Secure Authentication

Mr Vi — Tue, 22 Jul 2025 21:54:51 +0000

What is ConfWatch?

ConfWatch is a Python-based tool for monitoring and versioning configuration files. It provides a powerful CLI and a terminal-style web interface for managing configuration file changes, history, and diffs.

🚀 Key Features

Monitor any configuration files (dotfiles, .env, /etc/*, etc.)
Automatic versioning (Git-based, per-file, with unique safe names)
History for every file (see all changes with date and comment)
Diff between any two snapshots (choose any two versions to compare)
Terminal-style web interface (for easy browsing and diff viewing)
Secure authentication (unique password per installation)

🛠️ Installation

Quick Install (Recommended)

curl -fsSL https://raw.githubusercontent.com/mrvi0/conf-watch/main/install.sh | bash

The installer automatically:

Installs to ~/.confwatch/
Adds confwatch to your PATH
Creates virtual environment, config, repo, web interface
Generates a unique password for the web interface

Development Install

git clone https://github.com/mrvi0/conf-watch.git
cd conf-watch
./install-dev.sh

📝 Configuration

Edit ~/.confwatch/config/config.yml:

# List of files to monitor
- ~/.bashrc
- ~/.zshrc
- ~/.ssh/config
- ~/.env
- /etc/nginx/nginx.conf

💻 CLI Usage

# List monitored files
confwatch list

# Create snapshot with comment
confwatch snapshot ~/.bashrc --comment "After installing nvm"

# Show differences
confwatch diff ~/.env

# Show file history
confwatch history /etc/nginx/nginx.conf

# Tag current version
confwatch tag ~/.bashrc "after-nvm-install"

# Rollback to specific version
confwatch rollback ~/.bashrc abc1234

# Start web interface
confwatch web --port 9000

# Reset web interface password
confwatch reset-password

🌐 Web Interface

Run confwatch web and open http://localhost:8080

Features:

Secure authentication with unique password
Browse all monitored files
View change history with ability to compare any versions
Animated CLI demo
Terminal-style interface

🔐 Security

New authentication system in v3.0.0:

Each installation gets a unique password
No default passwords
Easy reset via CLI
SHA-256 password hashing

📊 Project Structure

~/.confwatch/
├── venv/                # Python virtual environment
├── config/config.yml    # List of monitored files
├── repo/                # Git repo with all file versions
├── web/                 # Web UI static files
├── confwatch            # Launcher script
└── confwatch-module/    # All Python code

🔍 Usage Examples

Monitoring dotfiles

confwatch snapshot ~/.bashrc ~/.zshrc --comment "Shell configuration update"

Tracking service configurations

confwatch snapshot /etc/nginx/nginx.conf --comment "Nginx configuration changes"

Comparing versions

confwatch diff ~/.env
confwatch history ~/.ssh/config

🆕 What's New in v3.0.0

✅ Secure authentication - unique password for each installation
✅ Improved web interface - logout button and dynamic version
✅ Password reset command - confwatch reset-password
✅ Updated documentation - detailed README in English and Russian

🤝 Contributing

The project is open for contributions! If you have ideas or found bugs:

Create an issue on GitHub
Fork the repository
Create a pull request

📚 Documentation

Conclusion

ConfWatch is an excellent tool for system administrators, developers, and anyone who wants to control changes in configuration files. Simple installation, powerful functionality, and beautiful web interface make it an indispensable assistant in daily work.

Try ConfWatch and share your impressions in the comments!

SSH Login Alert Bot

Mr Vi — Fri, 09 Dec 2022 07:01:21 +0000

How to use

Create telegram bot

To send a message to Telegram group or channel, you should first create your own bot. Just open Telegram, find @BotFather and type /start. Then follow instructions to create bot and get token to access the HTTP API.

Create Channel

Create a new Channel in Telegram and add your bot as a member. So your bot could send messages to the Channel.

In order to get Channel Id, first, post any message to the Channel. Then use this link template to get Channel Id:

https://api.telegram.org/bot<YourBOTToken>/getUpdates

Here is a response example:

{
  "ok":true,
  "result": [
    {
      "update_id":123,
      "channel_post": {
        "message_id":48,
        "chat": {
          "id":-123123123, // this is your channel id
          "title":"Notifications",
          "type":"channel"
        },
        "date":1574485277,
        "text":"test"
      }
    }
  ]
}

Clone the repo

git clone https://github.com/vi-dev0/login-alert-bot.git

Add token and chat ID

Add bot token and chat ID in telegram-send.sh

#!/bin/bash

GROUP_ID=<group_id>
BOT_TOKEN=<bot_token>

Add permissions

chmod +x telegram-send.sh
chmod +x login-notify.sh

Move to scripts folder

In order to use this script from everywhere and type telegram-send instead ./telegram-send.sh add it to /usr/bin/ folder

sudo mv telegram-send.sh /usr/bin/telegram-send

Owner of all files in /usr/bin is root user. So let's do the same with our script:

sudo chown root:root /usr/bin/telegram-send

You can test it:

telegram-send "Test message"

Move login-notify.sh script to /etc/profile.d/ folder

sudo mv login-notify.sh /etc/profile.d/login-notify.sh

Now re-login to your web server and check it works.

Contact

Mr Vi - @vi_dev0

Project Link: Login Alert Bot