Basta aprire una nuova scheda di Firefox e digitare nella barra degli indirizzi:

about:processes

Questo mostrerà un elenco di tutte le finestre con il titolo e la RAM usata e, oltretutto, la possibilità di scaricare direttamente la scheda per liberare RAM.

enjoy!

Uno dei principali punti di forza di UV è la velocità: l’installazione delle dipendenze e la creazione degli ambienti virtuali richiedono spesso solo pochi secondi, anche per progetti di grandi dimensioni. Questo è possibile grazie all’implementazione in Rust e a un sistema di caching molto efficiente.

Oltre alla rapidità, UV mette a disposizione un unico comando per gestire l’intero ciclo di vita di un progetto Python: creazione dell’ambiente virtuale, installazione delle librerie, sincronizzazione delle dipendenze e gestione del file di lock. Il risultato è un workflow più ordinato e facilmente riproducibile sia in sviluppo sia in produzione.

L’adozione di UV è in costante crescita anche grazie alla sua compatibilità con gli standard moderni dell’ecosistema Python, come il file pyproject.toml. Questo permette di integrarlo facilmente in progetti esistenti senza dover modificare radicalmente la struttura del codice.

Per chi sviluppa applicazioni Python, prova nuove librerie o gestisce pipeline di Continuous Integration, UV rappresenta oggi una valida alternativa agli strumenti tradizionali, capace di ridurre i tempi di lavoro e semplificare la gestione delle dipendenze.

Per installare UV possiamo digitare:

curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env

Per installare l’ultima versione di python digitiamo:

uv python install

una versione specifica di python, ad esempio la 3.13, digitiamo:

uv venv --python 3.13

A questo punto, per integrarlo in un progetto esistente possiamo digitare:

uv init
uv add -r requirements.txt
uv run main.py

enjoy!

Nel mio esempio il proxy è attivo sulla macchina host, pertanto lo si può “puntare” con il nome host.docker.internal avendo l’accortezza di aggiungere, come vedremo in avanti, nel file compose.yaml:

      extra_hosts:
        - "host.docker.internal:host-gateway"

Ipotizziamo che il Dockerfile contenga qualcosa di questo tipo:

# Stage 1: Dipendenze
FROM node:20-alpine AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app

dobbiamo aggiungere le necessarie variabili facendolo diventare:

# Stage 1: Dipendenze
FROM node:20-alpine AS deps
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

RUN apk add --no-cache libc6-compat
WORKDIR /app

ora passiamo a modificare il compose.yaml che da:

services:
  app:
    image: gest:latest
    build:
      context: .
      dockerfile: Dockerfile
      args:
        BUILD_GIT_SHA: ${BUILD_GIT_SHA:-unknown}
        BUILD_DATE: ${BUILD_DATE:-unknown}
    container_name: app-club
    restart: unless-stopped

dovrà diventare:

services:
  app:
    image: gest:latest
    build:
      context: .
      dockerfile: Dockerfile
      args:
        BUILD_GIT_SHA: ${BUILD_GIT_SHA:-unknown}
        BUILD_DATE: ${BUILD_DATE:-unknown}
        HTTP_PROXY: http://host.docker.internal:8888
        HTTPS_PROXY: http://host.docker.internal:8888
        NO_PROXY: 127.0.0.1,localhost
      extra_hosts:
        - "host.docker.internal:host-gateway"
    container_name: app-club
    restart: unless-stopped

enjoy!

Per l’isntallazione bastano pochi comandi:

curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | bash
apt-get install -y gitlab-runner

Poi accediamo all’interfaccia web di GitLab, andiamo nel progetto che ci interessa, poi “Settings” e “CI/CD“. Qui apriamo la sezione “Runners” e clicchiamo sul pulsante “Create project runner“. La procedura mostrerà un comando da scrivere nel terminale per agganciare il runner del progetto, in particolare c’è una chiave che serve per abilitare il runner. Recuperiamo la chiave e poi digitiamo:

sudo gitlab-runner register \
  --non-interactive \
  --url "SITE_URL" \
  --token "RUNNER_TOKEN" \
  --executor "docker" \
  --docker-image alpine:latest \
  --docker-pull-policy "if-not-present" \
  --description "docker-runner"

sostituendo SITE_URL con l’url del sito dove avete installato GitLab e RUNNER_TOKEN con il token recuperato nella procedura “Create project runner” avviata prima.

enjoy!

Partiamo con docker:

apt-get update
apt-get install apt-transport-https ca-certificates curl gnupg lsb-release

Rimuoviamo eventuali pacchetti installati prima:

apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)

Installiamo la chiave GPG

curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

Aggiungiamo il repository ad APT:

tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

Effettuiamo l’installazione vera e propria dell’ultima versione disponibile:

apt-get update
apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Nota: per installare una versione specifica, al posto dell’ultimo comando, facciamo:

apt list --all-versions docker-ce

VERSION_STRING=5:29.6.1-1~debian.12~bookworm
apt install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-buildx-plugin docker-compose-plugin

Ora verifichiamo se tutto è andato a buon fine:

systemctl status docker
systemctl start docker

e proviamo ad avviare un’immagine di esempio

docker run hello-world

Nota: per disinstallare docker:

apt purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

e rimuoviamo anche il riferimento al repository ed alla firma:

rm /etc/apt/sources.list.d/docker.sources
rm /etc/apt/keyrings/docker.asc

Infine, se vi interessa un sistema visuale per la gestione delle istanze docker, posso consigliarvi portainer che potete recuperare da github. Per l’installazione di default:

docker volume create portainer_data
docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest

Nota: se la macchina in questione è dietro un proxy, potreste ricevere il seguente errore:

docker: Error response from daemon: Get "https://registry-1.docker.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers).

Questo sicuramente è legato al fatto che docker non riesce ad utilizzare il proxy. Su Debian consiglio quanto segue:

mkdir /etc/systemd/system/docker.service.d

editare il file /etc/systemd/system/docker.service.d/http-proxy.conf ed inserire i parametri del proxy, es:

[Service]
Environment="HTTP_PROXY=http://proxyHost:proxyPort"
Environment="HTTPS_PROXY=http://proxyHost:proxyPort"
Environment="NO_PROXY=localhost,127.0.0.1"

Ricaricare l’unità di systemd:

systemctl daemon-reload

Verificare che le impostazioni siano state correttamente lette:

systemctl show --property Environment docker

riavviare il servizio docker, eseguire entrambe i comandi:

systemctl restart docker
service docker restart

E poi ripetere l’installazione di portainer, passando anche qui il proxy:

docker run -d -p 8000:8000 -p 9443:9443 -e "HTTPS_PROXY=http://proxyHost:proxyPort" --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest

Voglio ricordare che è possibile passare il proxy su docker in altri due modi:

Inserire nel file /etc/default/docker le informazioni del proxy, come segue:

export http_proxy='http://proxyHost:proxyPort'
export https_proxy='http://proxyHost:proxyPort'
export no_proxy=localhost,127.0.0.1

oppure creare il file ~/.docker/config.json ed inserire quanto segue:

{
"proxies": {
      "defaults": {
        "httpProxy":"http://proxyHost:proxyPort",
        "httpsProxy":"http://proxyHost:proxyPort",
        "noProxy":"localhost,127.0.0.1"
      }
    }
}

In ogni caso, ricordatevi di riavviare il servizio con:

service docker restart

Per verificare le impostazioni passate alle macchine guest, basterà eseguire questo comando:

docker container run --rm busybox env

enjoy!

Consiglio quindi di non installare la versione di mysqltuner presente nel repository ufficiale, ma piuttosto:

wget -O /usr/local/bin/mysqltuner https://raw.githubusercontent.com/major/MySQLTuner-perl/master/mysqltuner.pl
chmod +x /usr/local/bin/mysqltuner

enjoy!

L’installazione è molto semplice:

sudo -v ; curl https://rclone.org/install.sh | sudo bash

Oppure in modo specifico per MacOS:

brew install rclone

alla prima esecuzione bisogna configurare i dati di connessione:

rclone config

Questi gli step durante la configurazione (che poi viene scritta nel file ~/.config/rclone/rclone.conf):

• Premi n per n) New remote.
• Inserisci un nome, es eu2.
• Inserisci 5 per Amazon S3 Compatibile oppure 4 per Ceph Object Storage.
• Inserisci 1 per impostare le credenziali AWS o compatibili nel successivo step.
• Inserisci access_key per access_key_id.
• Inserisci secret_key, per secret_access_key.
• Premi invio per saltare la regione
• Inserisci l’endpoint url S3, es https://eu2.storage.ext.
• Premi invio per saltare la location_constraint.
• Premi invio per saltare le acl.
• Premi invio per saltare server_side_encryption.
• Premi invio per saltare sse_kms_key_id.
• Inserisci n per Modificare la configurazione avanzata.
• Inserisci y per confermare.
• Premi q per uscire dalla configurazione.

Dopo aver configurato la connessione, vediamo i principali comandi. Ipotizziamo che il nostro server si chiami eu2.

elenco file nel bucket test su server eu2:

rclone ls eu2:test/

elenco file, con dettagli, nel bucket test su server eu2:

rclone lsl eu2:test/

copio ker.txt dal bucket test dal server eu2 sul disco locale:

rclone copy eu2:test/ker.txt .

sync da /backup/ (source) verso server eu2 sul bucket cpanel(dest):

rclone sync -P /backup/ eu2:cpanel/ --s3-no-head

creo la cartella pluto:

rclone mkdir eu2:test/pluto

sposto pippo.txt nella cartella pluto:

rclone move eu2:test/pippo.txt ue2:test/pluto/

cancello la cartella pluto ed il realtivo contenuto, tipo rm -fr:

rclone purge eu2:test/pluto

cancello il file pippo.txt:

rclone delete eu2:test/pluto/pippo.txt

montare la cartella remota pluto in locale:

rclone mount eu2:pluto /mnt --vfs-cache-mode full --vfs-fast-fingerprint --no-modtime

enjoy!

102.219.170.XXX - - [30/Mar/2026:19:45:13 +0200] "GET /16/page/15/?lang=ko HTTP/1.1" 404 154085 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
103.189.194.XXX- - [30/Mar/2026:19:45:13 +0200] "GET /35/page/42/?lang=ko HTTP/1.1" 404 154085 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
200.8.173.XXX - - [30/Mar/2026:19:45:14 +0200] "GET /21/page/23/?lang=ko HTTP/1.1" 404 154085 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"

Si tratta sicuramente di uno scanner/bot che prova URL generati automaticamente e che non esistono nel sito. Come anticipato, il sito è attivo su WHM/cPanel ed ha nginx come reverse proxy (EA4 + nginx).

La soluzione più efficace in questo caso è creare una regola di nginx che blocchi le richieste prima ancora di essere passate ad apache.

Il file con le regole di nginx va posizionato in /etc/nginx/conf.d/users/[USERNAME]/ e chiamato con un suffisso .conf. In questo caso specifico possiamo scrivere nel file:

location ~ ^/[0-9]+/page/ {
access_log off;
return 444;
}

e poi riavviare nginx. Questo fa si che le richieste vengano direttamente chiuse senza risposta, senza scrivere log e senza avviare PHP.

enjoy!

I progetti PHP possono diventare rapidamente caotici quando ogni macchina scarica un set di dipendenze diverso. Composer aiuta a mantenere ordinate le librerie per i progetti PHP. Su Debian è possibile installarlo dai repository predefiniti o tramite il programma di installazione ufficiale.

Debian 13, 12 e 11 includono una versione meno recente di Composer nei repository predefiniti, mentre il programma di installazione ufficiale offre la versione più recente.

Attualmente sulla versione Debian 13 troviamo composer 2.8.x, sulla versione Debian 12 troviamo composer 2.5.x e sulla versione Debian 11 troviamo composer 2.0.x. Nel repository ufficiale la versione disponibile al momento è la 2.9.x.

Installare composer dal repository debian ufficiale

Questa è la modalità migliore se non si necessita dell’ultima versione di composer, perché l’aggiornamento dei pacchetti viene gestito automaticamente con il resto del S.O.

Possiamo installare composer con i seguenti comandi:

apt update
apt install php-cli php-curl ca-certificates unzip curl git -y
apt install composer -y

Installare composer dal sito ufficiale

Se invece si ha bisogno dell’ultima versione rilasciata, allora possiamo procedere come segue:

curl -sS https://getcomposer.org/installer -o composer-setup.php
php composer-setup.php --install-dir=/usr/local/bin --filename=composer
rm composer-setup.php

enjoy!

In questo caso basterà digitare:

dpkg-reconfigure tzdata

e cambiare il fusorario da utilizzare.

enjoy!