Consulente ICT ICT Consultant

The Problem: Disks Saturated by Log Files

Image generated with Gemini AI

Manual server maintenance is the enemy of efficiency. An IT sysadmin regularly has to free up disk space choked by old Apache/Nginx log files or ensure that critical configuration directories (e.g., /etc) are consistently backed up remotely. Forgetting these tasks leads to unplanned service outages.

The Solution: Bash Scripting and Cronjobs

We need to build a robust script that autonomously handles archiving critical data, purging obsolete files to free up inodes, and synchronizing everything to a secure off-site backup server.

1. The Bash Script for Backup and Cleanup

Create a file named server_maintenance.sh and paste this code. The script utilizes tar for compression, find to identify old logs, and rsync for secure transfer over SSH.

#!/bin/bash
# server_maintenance.sh - Backup and log rotation

BACKUP_DIR="/var/backups/daily"
TIMESTAMP=$(date +"%F")
TARGET_DIR="/etc"
REMOTE_SERVER="backup_user@10.0.10.50:/archive"

# 1. Creating the compressed archive
echo "[*] Creating backup for $TARGET_DIR..."
mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_DIR/etc_backup_$TIMESTAMP.tar.gz" "$TARGET_DIR"

# 2. Purging old logs (older than 30 days)
echo "[*] Rotating and deleting obsolete logs..."
find /var/log -name "*.log" -type f -mtime +30 -exec rm -f {} \;

# 3. Secure remote transfer
echo "[*] Syncing to the backup server..."
rsync -avz --delete "$BACKUP_DIR/" "$REMOTE_SERVER"

echo "[+] Maintenance completed successfully."

2. Execution Permissions and Scheduling

To make the script executable, modify the permissions:

chmod +x server_maintenance.sh

Now, let's delegate the automatic execution to the cron daemon. Open the cron table for the root user by running sudo crontab -e and add the following directive to trigger the script every night at 02:00 AM:

0 2 * * * /full/path/server_maintenance.sh >> /var/log/maintenance.log 2>&1

With this automation in place, the data lifecycle on your server is completely autonomous, performance-optimized, and disaster-proof.

Il Problema: I Dischi Saturati dai File di Log

Immagine realizzata con Gemini AI

La manutenzione manuale dei server è il nemico dell'efficienza. Un sistemista IT si trova regolarmente a dover liberare spazio su disco saturato da vecchi file di log di Apache/Nginx o a dover garantire che le directory di configurazione (es. /etc) siano costantemente sottoposte a backup remoto. Dimenticarsi queste operazioni causa interruzioni di servizio non pianificate.

La Soluzione: Scripting Bash e Cronjobs

Dobbiamo creare uno script robusto che si occupi autonomamente di archiviare i dati critici, rimuovere i file obsoleti per liberare spazio e sincronizzare il tutto su un server di backup sicuro.

1. Lo Script Bash per Backup e Pulizia

Crea un file chiamato server_maintenance.sh e inserisci questo codice. Lo script utilizza tar per la compressione, find per identificare i vecchi log e rsync per il trasferimento sicuro tramite SSH.

#!/bin/bash
# server_maintenance.sh - Backup e rotazione log

BACKUP_DIR="/var/backups/daily"
TIMESTAMP=$(date +"%F")
TARGET_DIR="/etc"
REMOTE_SERVER="backup_user@10.0.10.50:/archive"

# 1. Creazione dell'archivio compresso
echo "[*] Creazione backup per $TARGET_DIR..."
mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_DIR/etc_backup_$TIMESTAMP.tar.gz" "$TARGET_DIR"

# 2. Pulizia vecchi log (più vecchi di 30 giorni)
echo "[*] Rotazione e cancellazione log obsoleti..."
find /var/log -name "*.log" -type f -mtime +30 -exec rm -f {} \;

# 3. Trasferimento remoto sicuro
echo "[*] Sincronizzazione verso il server di backup..."
rsync -avz --delete "$BACKUP_DIR/" "$REMOTE_SERVER"

echo "[+] Manutenzione completata con successo."

2. Permessi di Esecuzione e Schedulazione

Per rendere lo script eseguibile, modifica i permessi:

chmod +x server_maintenance.sh

Ora deleghiamo l'esecuzione automatica al demone cron. Apri la tabella cron per l'utente root eseguendo sudo crontab -e e aggiungi la seguente direttiva per far girare lo script ogni notte alle 02:00:

0 2 * * * /percorso/completo/server_maintenance.sh >> /var/log/maintenance.log 2>&1

Con questa automazione, il ciclo di vita dei dati sul tuo server è completamente autonomo, ottimizzato per le prestazioni e sicuro contro i disastri.

Image generated with Gemini AI

The Problem: Cleartext Passwords in Source Code

Automation via scripting is the beating heart of system administration. However, hardcoding credentials (passwords, API tokens, cryptographic keys) in cleartext inside .sh or .ps1 files is a critical security violation. Anyone with read access to the file system or the Git repository compromises the entire corporate ecosystem.

The Solution: Encrypted Secrets Management

We must decouple the script's logic from the sensitive data by leveraging the operating system's native protection mechanisms.

1. In PowerShell Environments (Windows)

In Microsoft infrastructures, we can use Export-Clixml to encrypt a credential object. The encryption is tightly bound to the user account that generated it and the physical machine (thanks to the Windows Data Protection API).

# Run once to save the encrypted password
Get-Credential | Export-Clixml -Path "C:\secure\admin_creds.xml"

# In the production script, call the file:
$cred = Import-Clixml -Path "C:\secure\admin_creds.xml"

2. In Bash Environments (Linux)

On Unix systems, the most immediate, zero-cost method to protect daemons and cron scripts is to isolate variables into a separate configuration file, restricting permissions exclusively to the root user.

# Create the protected configuration file
echo "DB_PASS='SuperSecret!'" > /etc/script_secrets.conf
sudo chmod 400 /etc/script_secrets.conf

In the main script (executed with elevated privileges), simply import the variables using the source /etc/script_secrets.conf command. The code remains clean, and credentials remain invisible to unauthorized users.

Il Problema: Password in Chiaro nei Sorgenti

L'automazione tramite scripting è il cuore nevralgico della gestione sistemistica. Tuttavia, hardcodare credenziali (password, token API, chiavi crittografiche) in chiaro all'interno di file .sh o .ps1 è una violazione critica della sicurezza. Chiunque abbia accesso in lettura al file system o al repository Git compromette l'intero ecosistema aziendale.

Immagine realizzata con Gemini AI

La Soluzione: Gestione Cifrata dei Segreti

Dobbiamo disaccoppiare la logica dello script dal dato sensibile, sfruttando i meccanismi di protezione nativi del sistema operativo.

1. In Ambiente PowerShell (Windows)

In infrastrutture Microsoft, possiamo usare Export-Clixml per cifrare un oggetto credenziale. La cifratura è legata a doppio filo all'account utente che l'ha generata e alla macchina fisica (grazie alle API di Data Protection di Windows).

# Eseguire una volta per salvare la password cifrata
Get-Credential | Export-Clixml -Path "C:\secure\admin_creds.xml"

# Nello script di produzione, richiamare il file:
$cred = Import-Clixml -Path "C:\secure\admin_creds.xml"

2. In Ambiente Bash (Linux)

Nei sistemi Unix, il metodo più immediato e a costo zero per proteggere i demoni e gli script cron è isolare le variabili in un file di configurazione separato, restringendo i permessi esclusivamente all'utente root.

# Creare il file di configurazione protetto
echo "DB_PASS='SuperSegreta!'" > /etc/script_secrets.conf
sudo chmod 400 /etc/script_secrets.conf

Nello script principale (eseguito con privilegi elevati), basta importare le variabili con il comando source /etc/script_secrets.conf. Il codice rimane pulito e le credenziali risultano invisibili agli utenti non autorizzati.