Catégorie : linux

Comment utiliser Hyperfine ?

Comment utiliser Hyperfine pour comparer les performances de rg et ag

Qu’est-ce que Hyperfine ?

Hyperfine est un outil en ligne de commande qui permet de mesurer et de comparer les performances d’autres commandes. Il est particulièrement utile pour évaluer la vitesse d’exécution de différentes commandes ou scripts, en fournissant des statistiques détaillées comme le temps moyen, l’écart-type, et la plage de temps d’exécution.

Présentation de rg (ripgrep)

Ripgrep, souvent abrégé en rg, est un outil de recherche de texte ultra-rapide. Il est conçu pour parcourir rapidement des fichiers et des répertoires à la recherche de motifs spécifiques. Ripgrep est connu pour sa rapidité et sa capacité à ignorer les fichiers non pertinents, comme ceux dans les répertoires .git ou node_modules.

Présentation de ag (The Silver Searcher)

The Silver Searcher, ou ag, est un autre outil de recherche de texte, similaire à ack, mais plus rapide. Il est optimisé pour la recherche dans des projets de code, en ignorant automatiquement les fichiers et répertoires non pertinents. Bien qu’il soit rapide, il est souvent surpassé par rg en termes de performances.

Comparaison des performances avec Hyperfine

Pour comparer les performances de rg et ag, nous pouvons utiliser Hyperfine avec la commande suivante :

hyperfine --warmup 3 'rg -i "Olivier" -g "*php*" .' 'ag -i "Olivier" -G "php"'

Les résultats montrent que rg est significativement plus rapide que ag :

  • rg a un temps moyen d’exécution de 256.6 ms.
  • ag a un temps moyen d’exécution de 910.3 ms.

En résumé, rg est environ 3.55 fois plus rapide que ag dans ce scénario.

Pourquoi utiliser rg plutôt que ag ?

La comparaison effectuée avec Hyperfine démontre clairement que rg est plus performant que ag pour la recherche de texte. Si la vitesse est un critère important pour vous, rg est donc un choix évident. De plus, rg offre une meilleure gestion des fichiers ignorés et une intégration plus fluide avec les outils modernes de développement.

En conclusion, si vous cherchez un outil de recherche de texte rapide et efficace, rg est une excellente option, surtout lorsque vous travaillez sur des projets de grande envergure où chaque milliseconde compte.

Automatiser le nettoyage des branches Git avec un alias : Guide pratique

Automatiser le nettoyage des branches Git avec un alias : Guide pratique

Travailler avec Git implique souvent de gérer de nombreuses branches, locales et distantes. Au fil du temps, il est courant que des branches distantes soient supprimées, laissant des branches locales obsolètes. Pour simplifier le nettoyage de ces branches, vous pouvez créer un alias Git qui automatise ce processus. Dans cet article, nous vous expliquons comment faire, ainsi que les avantages et les inconvénients de cette méthode.

Créer un alias Git pour nettoyer les branches locales

Voici la commande pour créer un alias Git nommé prune-all qui nettoie automatiquement les branches locales obsolètes :

git config --global alias.prune-all '!git fetch --prune && git branch -vv | grep ": gone]" | sed "s/^[[:space:]]*\([^[:space:]]*\).*/\1/" | xargs -r git branch -d'

Une fois cet alias configuré, vous pouvez simplement exécuter :

git prune-all

Cette commande va :

  1. Mettre à jour les références locales et supprimer les branches distantes supprimées (git fetch --prune).
  2. Identifier les branches locales qui n’ont plus de branche distante associée (git branch -vv | grep ": gone]").
  3. Extraire les noms de ces branches (sed).
  4. Supprimer les branches locales (xargs -r git branch -d).

Pourquoi utiliser cet alias ?

Cet alias offre plusieurs avantages :

  • Gain de temps : Plus besoin d’exécuter manuellement plusieurs commandes pour nettoyer les branches locales.
  • Automatisation : Le processus est entièrement automatisé, ce qui réduit les erreurs humaines.
  • Propreté du dépôt : Vous gardez votre dépôt local propre et synchronisé avec le dépôt distant.

Les précautions à prendre

Bien que cet alias soit très utile, il est important de comprendre ses limites et les risques potentiels :

  • Utilisation de git branch -d : L’alias utilise git branch -d pour supprimer les branches locales. Cela signifie que Git refusera de supprimer une branche si elle contient des commits non fusionnés. C’est une sécurité pour éviter de perdre du travail.
  • Risque de suppression accidentelle : Si vous utilisez git branch -D (avec un D majuscule) à la place de -d, les branches seront supprimées de force, même si elles contiennent des commits non fusionnés. Soyez prudent si vous modifiez l’alias pour utiliser -D.
  • Vérification manuelle : Avant d’exécuter l’alias, il peut être utile de vérifier les branches qui seront supprimées en exécutant :
git fetch --prune && git branch -vv | grep ": gone]"

Quand utiliser cet alias ?

Cet alias est particulièrement utile dans les situations suivantes :

  • Vous travaillez sur un projet avec de nombreuses branches, et vous voulez garder votre dépôt local propre.
  • Vous collaborez avec une équipe et les branches distantes sont fréquemment supprimées après fusion.
  • Vous voulez automatiser une tâche répétitive pour gagner du temps.

Conclusion

Créer un alias Git pour nettoyer les branches locales est une excellente façon d’automatiser une tâche fastidieuse et de garder votre dépôt propre. En utilisant git branch -d, vous ajoutez une couche de sécurité pour éviter de perdre du travail non fusionné. Cependant, soyez conscient des risques si vous décidez d’utiliser git branch -D à la place.

N’hésitez pas à essayer cet alias et à l’adapter à vos besoins. Bonne gestion de branches !

Vous avez des questions ou des suggestions ? Laissez un commentaire ci-dessous !

Linux Mint : améliorer votre terminal ZSH avec l’auto-suggestion et la coloration syntaxique

Comment améliorer votre terminal ZSH avec l’auto-suggestion et la coloration syntaxique

Vous utilisez ZSH comme shell par défaut mais vous souhaitez le rendre plus puissant et agréable à utiliser ? Dans cet article, nous allons voir comment installer et configurer deux plugins essentiels : zsh-autosuggestions pour l’auto-complétion intelligente et zsh-syntax-highlighting pour la coloration syntaxique en temps réel.

Prérequis

  • ZSH installé comme shell par défaut
  • Git installé sur votre système
  • Droits d’accès à votre répertoire personnel

Installation des plugins

Commençons par créer un dossier dédié pour nos plugins ZSH et clonons les dépôts nécessaires :

mkdir -p ~/.zsh
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
git clone https://github.com/zsh-users/zsh-syntax-highlighting ~/.zsh/zsh-syntax-highlighting

Configuration

1. Activation des plugins

Ajoutez ces lignes à votre fichier ~/.zshrc pour activer les plugins :

source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
source ~/.zsh/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

2. Mise à jour de la liste des plugins

Si vous utilisez Oh My Zsh, modifiez la ligne des plugins dans votre fichier ~/.zshrc :

plugins=(git thefuck poetry zsh-autosuggestions zsh-syntax-highlighting)

Fonctionnalités

Auto-suggestions

Le plugin zsh-autosuggestions vous suggère des commandes basées sur votre historique pendant que vous tapez. Pour accepter une suggestion, appuyez simplement sur la touche ➡️ (flèche droite).

Coloration syntaxique

zsh-syntax-highlighting colore vos commandes en temps réel :

  • Commandes valides en vert
  • Commandes invalides en rouge
  • Options et arguments en couleurs distinctes
  • Chemins de fichiers existants soulignés

Conclusion

Avec ces deux plugins, votre terminal ZSH devient beaucoup plus convivial et efficace. L’auto-suggestion vous fait gagner du temps en proposant les commandes pertinentes, tandis que la coloration syntaxique vous aide à repérer rapidement les erreurs de frappe.

Conseils bonus

  • Redémarrez votre terminal ou exécutez source ~/.zshrc pour appliquer les changements
  • Vous pouvez personnaliser les couleurs et le comportement des plugins en consultant leur documentation respective sur GitHub
  • Ces plugins sont compatibles avec la plupart des frameworks ZSH comme Oh My Zsh et Prezto

N’hésitez pas à laisser un commentaire si vous rencontrez des difficultés ou si vous souhaitez partager d’autres astuces pour améliorer votre terminal !

Commandes à exécuter pour installer Chrome sur une nouvelle installation Linux Mint

Comment installer Google Chrome sur Linux (Ubuntu/Debian) – Guide complet

Dans ce guide, vous découvrirez comment installer facilement Google Chrome sur votre distribution Linux (Ubuntu ou Debian) en utilisant le terminal. Suivez ces étapes simples pour une installation réussie.

Étapes d’installation détaillées

  1. Créer le dossier pour les clés de sécurité
    Cette étape permet de préparer le système pour stocker les clés de sécurité Google.
  2. Télécharger et installer la clé Google
    Nous récupérons la clé officielle de Google pour garantir l’authenticité des paquets.
  3. Ajouter le dépôt Chrome
    Configuration du dépôt officiel dans votre système pour accéder aux paquets Chrome.
  4. Mettre à jour la liste des paquets
    Actualisation de votre système avec le nouveau dépôt ajouté.
  5. Installer Chrome
    Installation finale du navigateur sur votre système.

Commandes à exécuter

Copiez et collez ces commandes une par une dans votre terminal :

sudo mkdir -p /etc/apt/keyrings

curl -fsSL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /etc/apt/keyrings/google-chrome.gpg

echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-chrome.gpg] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list

sudo apt update

sudo apt install google-chrome-stable

Vérification de l’installation

Une fois l’installation terminée, vous pouvez :

  • Lancer Chrome depuis votre menu d’applications
  • Ou utiliser la commande google-chrome dans le terminal

En cas de problème lors de l’installation, assurez-vous d’avoir les droits administrateur et que votre système est à jour.

ssh : les nouveaux types de cryptographies et clés pour plus de sécurité

GitHub et GitLab ont adopté des normes de sécurité SSH plus récentes et plus robustes pour renforcer la sécurité des connexions.

En remplacement, GitHub a introduit les clés hôtes ECDSA et Ed25519, qui sont basées sur la cryptographie à courbe elliptique, offrant ainsi de meilleures caractéristiques de sécurité pour des augmentations modestes de taille et de calcul.

Aujourd’hui, on recommande l’utilisation de clés SSH ED25519, qui sont plus sécurisées et devraient être disponibles sur n’importe quel système. Bien sûr quand on parle de système Linux on est sûr qu’elles sont déjà présentes.

Il est essentiel de générer des paires de clés SSH sûres et de les configurer correctement. Par défaut une clé de 1024 bits est générée, il faut donc impérativement changer la taille de la clé par au minimum 4096 :

ssh-keygen -t rsa -b 4096

Expressions régulières

Regexp hints / aide

Récupéré ici, traduction à finir

Caractères

Caractères Explication Exemple Chaînes qui « matchent »
[abc]
[a-c]
Fait correspondre les caractères / la plage de caractères donné(e)s abc[abc] abca
abcb
abcc
[^abc]
[^ac]
Négation des caractères / la plage de caractères donnés abc[^abc] abcd
abce
abc1
...
. Tout caractère sauf saut de ligne bc. bca
bcd
bc1
b.
...
\d Tout caractère numérique (équivalent à [0-9]) c\d c1
c2
c3
...
\D Tout caractère non numérique (équivalent à [^0-9]) c\D cA
cB
c*
...
\w Tout caractère alphanumérique (équivalent à [A-Za-z0-9_]) a\w aa
a1
a_
...
\W Tout caractère non alphanumérique (équivalent à [^A-Za-z0-9_]) a\W a)
a$
a?
...
\s Généralement utilisé pour les espaces blancs, mais peut être utilisé pour les nouvelles lignes, tabulations, etc. a\s [espace]
\S Tout sauf un espace blanc ou nouvelle ligne ou tabulation. a\S aa
\t Tabulation horizontale t\txy t[tab]xy
\r Correspond à un retour chariot AB\r\nCD AB[\return]CD
\n Correspond à un saut de ligne AB\r\nCD AB[\return]CD
| Correspond à « x » ou « y » aa|bb aa
bb
Chars Définition Ex match
Chars Définition Ex match
Chars Définition Ex match
Commentaires fermés sur Expressions régulières Publié dans

Supprimer les plus vieux fichiers d’un dossier tant qu’on dépasse une certaine taille


Exemples de lancement du script

Notez qu’il faut lancer en utilisant « source« 

  • Supprimer les plus vieux fichiers du dossier courant (./) tant qu’il prend plus de 96Mo :
    source ./clean_custom.sh --path ./ -l 9600000
  • Supprimer les plus vieux fichiers du dossier temporaire (/tmp/) tant qu’il prend plus de 2Go :
    source ./clean_custom.sh --path /tmp/ -l 2000000000

Code du script

#!/usr/bin/env bash                                                              
PATH_TO_CLEAN=                                                                   
NUMBER_FILES_TO_DELETE_EACH_LOOP=1                                               
SIZE_LIMIT=2000000000                                                            
                                                                                 
# ----------------------------------------------------------------------------   
# usage:                                                                         
usage()                                                                          
{                                                                                
    echo "Clean directory: while size of a dir > limit, oldest files first."
    echo "Usage: ${filename} [-p|--path path] [-s|--max-size size] | [-h]"
    echo "    -p|--path: path to clean"            
    echo "    -l|--limit: max size for the folder (must be > 0)"
    echo "    -h|--help this help"                 
}                                                                                
                                                                                 
# ----------------------------------------------------------------------------   
# handling arguments:                                                            
args=("$@")                                                            
filename=$(basename -- "$0" | sed 's/\(.*\)\..*/\1/')        
while [ "$1" != "" ]; do                                     
    case $1 in                                               
        -p | --path ) shift              
                      # stop if path doesn't exist:
                      if [ ! -d "$1" ]; then
                          echo "Path not found: '$1'"
                          usage
                          return 1
                      fi
                      PATH_TO_CLEAN=$1
                      ;;
        -l | --limit ) shift             
                       SIZE_LIMIT=$(echo $1 | bc)
                       if [ $SIZE_LIMIT -le 0 ]
                       then
                           usage
                           return 1
                       fi
                       ;;
        -h | --help ) usage              
                      return
                      ;;
        * ) usage                        
            return 1 
    esac                                                     
    shift                                                    
done                                                                             
[ -z "$PATH_TO_CLEAN" ] && echo "Path empty" && usage && return 1
echo "Cleanin dir: '$PATH_TO_CLEAN', size limit=$SIZE_LIMIT" 
# ----------------------------------------------------------------------------   
# handling arguments:                                                            
while [ 1 ]                                                                      
do                                                                               
    s=$(du -sb $PATH_TO_CLEAN | cut -f1 | bc)                
    if [ $s -gt $SIZE_LIMIT ]                                
    then                                                     
        find $PATH_TO_CLEAN -type f -printf '%T+ %p\n' | \
            sort -nr | \
            tail -$NUMBER_FILES_TO_DELETE_EACH_LOOP | \
            cut -d' ' -f 2- | \
            xargs -I {} rm -f {}
    else                                                     
        break                            
    fi                                                                                                                                                                                                                                                      
done                                                                             
return 0

Python : compiler et faire tourner plusieurs versions sans collisions

Il faut aller chercher le code source qui vous intéresse.

Exemple, faire tourner un « vieux » Python 3.6, aller dans les versions ici et prendre celle qui nous intéresse.

Puis récupérer le code source et le compiler :

mkdir ~/source ; cd ~/source
wget https://www.python.org/ftp/python/3.6.13/Python-3.6.13.tar.xz
tar xvf Python-3.6.13.tar.xz
cd ~/source/Python-3.6.13
./configure && make
sudo make altinstall

Et voilà :

~/source/Python-3.6.13$ python3.6
Python 3.6.13 (default, May 21 2021, 17:12:12) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Linux : comment monter un disque réseau automatiquement

Sous Mint, Lorsque mon PC démarre, je veux qu’il « monte » automatiquement mes disques et qu’il fasse quelques vérifications au passage (dossier existant etc).
Problème : il arrive parfois la même chose que sous Windows, à savoir que si le mount ne fonctionne pas, il faut le faire à la main.
J’ai donc essayé de suivre plusieurs tutoriels et la plupart disaient d’ajouter dans les tâches planifiées (« cronjob« ) une ligne qui commençait par @reboot.

Je ne sais pas pourquoi, mais sur ma version de Mint, il ne connaissait pas @reboot.

Après pas mal de recherches, voici ce que j’ai trouvé, et qui fonctionne parfaitement :

  • Éditer /etc/rc.local
  • Lui ajouter la ligne de commande que l’on veut faire

Donc mon fichier /etc/rc.local j’ai donc deux lignes de code :
/home/olivier/apply.config.perso.sh -f /home/olivier/boot.log
exit 0

(J’ai enlevé les commentaires très importants qu’il y a dans le fichier, à vous de les lire !)
Le code précédent signifie « lance le script /home/olivier/apply.config.perso.sh« .

Et je me suis fait mon script, soit /home/olivier/apply.config.perso.sh :

(Il prend en compte le paramètre « -f » pour préciser le fichier de sortie, comme cela je logue tout, on n’est jamais assez prudent).
# ----------------------------------------------
# command line options
# first save args to pass them later on to other scripts:
args=("$@")
while [ "$1" != "" ]; do
    case $1 in
        -f | --file ) shift
                                # test if output_filename starts with "-":
                                if [[ "$1" =~ ^-.* ]]; then
                                    usage
                                    exit
                                fi
                                # from that point on:
                                # direct all stdout and stderr to $1:
                                exec &>>$1
                                ;;
        -u ) # ignored here, for mount script (later in there)
                                ;;
        -h | --help ) usage
                                exit
                                ;;
        * ) usage
                                exit 1
    esac
    shift
done
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Applying my own configuration..."
sudo -Hu olivier gsettings set org.cinnamon.settings-daemon.peripherals.keyboard delay 120
sudo -Hu olivier gsettings set org.cinnamon.settings-daemon.peripherals.keyboard repeat-interval 18
if mountpoint -q "/mnt/Olivier"; then
    echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Already mounted, nothing to do."
else
    delay=1
    while ! mountpoint -q "/mnt/Olivier"; do
        echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Trying to mount..."
        # re-pass the same arguments via "${args[@]}"
        /home/olivier/mount.diskstation.sh "${args[@]}"
        sleep $delay
        if [ "$delay" -gt 60 ]; then
            echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Couldn't mount! Too long! Exiting."
            exit 1
        fi
        delay=$((delay+5))
    done
    echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Successful mount."
fi
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Done."

Explications :

Les deux ordres gsettings set org.cinnamon.settings-daemon.peripherals.keyboard modifient la vitesse de mon clavier (qui n’est, de base, pas assez rapide pour moi).

L’ordre /home/olivier/mount.diskstation.sh monte mon disque.

Ensuite je fais une boucle qui vérifie si mon « mount » est réussi ou pas : tant que ce n’est pas le cas, il attend un « compteur » qu’il augmente de 5s à chaque boucle, et tout ça au maximum 60 fois. Si vraiment il n’y arrive pas, il logue le problème et quitte.

Tout fonctionne parfaitement depuis maintenant 2 ans !

python, flask, https et wsgi howto

Je ne vais pas dire le temps que j’ai passé à réussir à mettre ça en oeuvre si quelqu’un fait ça en quelques minutes j’aurais honte… mais disons que j’ai passé beaucoup de temps à le faire tourner, mais je suis vraiment impressionné par sa rapidité. Voici – via ma petite expérience – comment faire tourner un serveur Web très optimisé, en mode production  :
  • flask
  • wsgi
  • https

https / certbot

Je vous donne des pistes, à vous de finir.
L’idée, c’est que je veux paramétrer pour la n-ième fois un nouveau nom de domaine via certbot, et je ne veux pas qu’il touche à la conf de nginx. L’idée c’est que :
(1) Je le fais simplement via certbot-auto puis après,
(2) toutes les autres fois j’utilise « -d » pour qu’il ne touche pas à la conf, et je le fais à la main, en m’inspirant de la conf que cert-bot a fait dans le (1)
Donc, pour faire le (1), je demande à certbot de me créer uniquement le certificat : ./certbot-auto certonly -d monsite.fr
Pour le https, regardez ici.

Python

Code exemple, qui lit un fichier JSON, lance le serveur et sert le fichier lu en tant que JSON :

import json

from flask import Flask, jsonify

app = Flask(__name__)

with open("mon fichier JSON", 'r') as f:
    json_levels_full_description = json.load(f)


@app.route('/')
def index():
    return jsonify(json_levels_full_description)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8004)
else:
    application = app

Attention : surtout ne faites pas le classique if __name__ == '__main__' car uwsgi inclut ce fichier, donc ce fichier n’est jamais un __main__, par contre la configuration au lancement a besoin d’une variable globale nommée application.

Nginx

Je copie colle la configuration d’un site qui tourne déjà en https, en voici un extrait diminué à mort pour ne pas polluer avec des règles personnelles, regardez bien le texte en gras, c’est le plus important pour faire tourner Nginx en collaboration avec wsgi :

server {
  server_name "~(www\.)?monsite\.(com|fr|org|biz|be)$";

  index index.html index.htm;

  access_log /blah/proxy-access.monsite.log proxylog;
  error_log /blah/proxy-error.monsite.log error;

  listen 443 ssl;
  ssl_certificate /blah/fullchain.pem;
  ssl_certificate_key /blah/privkey.pem;
  include /blah/options-ssl-nginx.conf;
  ssl_dhparam /blah/ssl-dhparams.pem;

  location / {
    include denied_clients;

    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Server $host;

    # (!) here it's uwsgi:
    include uwsgi_params;
    uwsgi_pass 127.0.0.1:8002;

  }
}

# redirect http -> https:
server {
  listen *:80;
  server_name "~^monsite\..*$";
  return 302 https://$host$request_uri;
}

Flask

Pour installer flask, et uwsgi, faites un environnement virtuel puis installez les deux :

$ python3 -m venv venvpython.3.6.6
$ source venvpython.3.6.6/bin/activate
$ pip install --upgrade pip
$ pip install flask

uwsgi

Il faut être dans le venv activé (voir paragraphe précédent), puis l’installer via pip :

$ pip install uwsgi

Enfin, le script de lancement !

uwsgi --chdir=/web/htdocs/blah \
    --module=flask_server:application \
    --master --pidfile=/tmp/uwsgi.blah.pid \
    --socket=127.0.0.1:8004 \
    --processes=5 \
    --uid=1000 --gid=2000 \
    --harakiri=20 \
    --max-requests=5000 \
    --vacuum \
    --home=/web/htdocs/blah/venvpython.3.6.6

flask_server correspond au fichier python flask_server.pydécrit dans la section python au début et application est le nom de la variable globale (lisez le code de la section python)

Lorsque vous le lancerez, tout se passera bien, mais l’exécutable ne sera pas en tâche de fond. Cela a un avantage : un CTRL-C et vous l’arrêtez ! L’inconvénient, c’est que vous n’avez pas la main.

Si vous voulez le lancer en tâche de fond et qu’il écrive les logs dans un fichier, ajoutez l’option     --daemonize=/var/log/uwsgi/blah.uwsgi.log


Notes d’amélioration :
– Le port 8004 peut être passé en tant que variable d’environnement à l’application flask via le paramètre `env` de la commande uwsgi, ce qui rend le code plus portable ;
– Les paramètres uwsgi peuvent être consignés dans un fichier my_app.ini et uwsgi serait alors lancé en faisant uwsgi my_app.ini