Instant geek !
- Publié le 14 février 2009 à 19:13
- 1 commentaire
Malgré un petit avertissement à l'installation, PuTTY fonctionne bien sous Nokia 5800, indispensable ;-)
Quelques trucs avec ViM #1
- Publié le 20 février 2007 à 00:48
- 8 commentaires
ViM est un formidable éditeur de texte. Bien sûr celui-ci demande un peu d'investissement avant d'être productif mais une fois franchi ce cap, il est vraiment très agréable de garder les mains sur le clavier pour toutes les tâches d'édition. Il est aussi très pratique d'utiliser le même éditeur de texte pour éditer un fichier de configuration au coup par coup sur un serveur et pour écrire de manière plus élaborée (programmation, e-mail, ...), on finit même par taper des commandes ViM dans le terminal ce qui oblige à définir des alias bizarres :-)
Je ne vais pas faire ici une introduction à l'utilisation de ViM car cela a déjà été bien fait mais plutôt donner quelques recettes de cuisine bien pratiques.
Le fichier .vimrc
Pour commencer, il faut configurer la bête :-) Pour cela, il faut créer ou éditer le fichier .vimrc dans votre dossier personnel, par exemple avec vim. Voici un .vimrc de base :
set nocompatible " pas compatibilité avec vi " priorité faible pour les fichiers avec les extensions " suivantes lors du complètement set suffixes=.bak,~,.swp,.o,.info,.aux,.log,.dvi,.bbl,.blg,.brf,.cb,.ind,.idx,.ilg,.inx,.out,.toc set history=50 " 50 lignes dans l'historique set ruler " affiche la position du curseur en bas set sm " affiche la parenthèse correspondante set formatoptions=tcroqn " indentation set autoindent set cin set textwidth=0 " pas de coupure de ligne par défaut set backspace=2 set ts=4 " tabulation sur 4 caractères set sw=4 set nobackup " pas de fichier backup set dir=~/tmp " fichier temporaire dans ~/tmp (il faut qu'il existe !) set autowrite set hlsearch " surligne les recherches set incsearch " recherche au fur et à mesure syntax on " coloration syntaxique set background=dark " fond noir par défaut
Ce fichier est évidemment à adapter en fonction de votre utilisation, constitue déjà une bonne base pour se faciliter l'édition avec ViM. Comme toujours, en cas de doute sur un paramètre, il ne faut pas hésiter à consulter l'aide très complète en tapant :help le_paramètre pour voir de quoi il retourne.
Quelques trucs rapides
Afficher les numéros de lignes
Il suffit de taper :set nu et :set nu! pour les cacher. Si vous voulez toujours afficher les numéros de ligne, il suffit d'ajouter set nu dans votre .vimrc.
Éditer des fichiers distants via SSH
Il est bien sûr possible de se connecter en SSH et d'utiliser ViM sur la machine distante, mais il n'est peut être pas configurer voire pas installé du tout... La commande suivante me permet d'éditer mon .bashrc et le fichier /tmp/unfichier sur ma Dedibox :
$ vim 'scp://tigrou@pwet.fr/.bashrc' 'scp://tigrou@pwet.fr//tmp/unfichier'
Trier les lignes d'un fichier
ViM ne sait pas le faire directement, par contre, on peut utiliser la commande externe sort pour le faire. Pour cela, il suffit de taper :%!sort, ce qui aura pour effet de donner le contenu du buffer courant en entrée de la commande sort et de le remplacer par sa sortie.
Insèrer le résultat d'une commande
En tapant :%!la_commande, on remplace le contenu du buffer par la sortie de la commande. En tapant :r!la_commande, on insère son résultat. Par exemple pour insérer la date courante, on peut faire :r!date.
Être à l'aise avec bash #5
- Publié le 26 novembre 2006 à 16:53
- 4 commentaires
Résumé des épisodes précédents :
- Le prompt bash et la manipulation des titres des fenêtres
- Navigation dans les répertoires en ligne de commande et les alias
- L'historique et le complètement avancé avec bash
- Les entrée/sorties, leur redirection et les motifs du shell
Ce billets est quant à lui consacré à l'enchaînement de commandes, au contrôles des tâches ( jobs) puis à deux petites astuces bien pratiques à utilisées sans modération. Je pense que ce billet est le dernier de cette série, les prochains autour du shell seront probablement sur les scripts et diverses astuces plus ou moins pointues comme les deux présentées à la fin de ce billet.
Enchaîner les commandes
L'utilisation probablement la plus courante d'un shell consiste à taper une commande, regarder sa sortie ou son résultat et éventuellement recommencer en fonction du résultat précédent. On peut aussi vouloir exécuter plusieurs commandes à la suite. Pour cela, on peut écrire un script ou une fonction bash (ce sera probablement l'objet d'une prochaine série de billets) mais il est aussi possible de le faire en mode interactif.
Plusieurs commandes à la suite sans condition
Pour éxécuter plusieurs commandes de suite, il est possible de les écrire les unes à la suite des autres en les séparant par un point-virgule, par exemple :
> tigrou@Lorien[192.168.0.243]:~$ cd /tmp ; find . -type d -user tigrou > liste_dossiers ; cd ; cat /tmp/liste_dossiers ./orbit-tigrou ./ssh-QSQBhp4238 ./gconfd-tigrou ./gconfd-tigrou/lock ./.exchange-tigrou ./listen
Cette liste de 4 commandes est regroupée sur une ligne, j'aurais aussi bien pu taper chacune d'elle sur une ligne séparée, le résultat aurait été le même. Si l'une d'entre elles échoue, les autres sont quand même exécutées.
Plusieurs commandes à la suite sous condition
Chaque commande lancée renvoie normalement un code de retour. Par convention, un résultat normal (sans erreur) renvoie un code de retour égale à zéro, si quelque chose se passe mal, ce code est différent de zéro et peu avoir différentes significations selon les programmes. La variable $? contient le code de retour de la précédente commande lancée. En séparant des commandes par &&, bash vérifie que la commande a bien renvoyé un code de retour nulle avant d'éxécuter la suivante, sinon il interrompt la suite, exemple :
> tigrou@Lorien[192.168.0.243]:~$ test -L /tmp > tigrou@Lorien[192.168.0.243]:~$ echo $? 1 > tigrou@Lorien[192.168.0.243]:~$ test -e /tmp && echo "/tmp existe" && test -L /tmp && echo "/tmp est un lien symbolique" /tmp existe
Cette suite de commande est interrompue après le test -L car son code de retour n'est pas nulle puisque /tmp n'est pas un lien symbolique.
Contrôle des tâches
En ajoutant le caractère & à une commande, celle-ci est lancée en arrière plan tout en restant "attaché" au shell qui l'a lancé. On peut aussi faire passer en arrière plan une commande avec le raccourci Ctrl+z. Pour récupèrer la main sur le programme passé en arrière plan, il est possible d'utiliser la commande fg. J'utilise couramment ce mécanisme lorsque j'édite un fichier à l'aide de vim en ssh et que je me rend compte que je dois lancer une autre commande, je peux alors faire Ctrl+z pour récupèrer le shell, je lance ma commande puis je tape fg pour reprendre la main sur mon éditeur. fg accepte en paramètre un entier qui indique le numéro de la tâche à remettre en avant plan. Ce numéro correspond à l'ordre dans lequel les programmes ont été mis en arrière plan.
Quelques trucs...
Un peu de couleurs avec grep
Les émulateurs de terminal sont capables d'afficher quelques couleurs (en général 16). La configuration par défaut sous la plupart des distributions fait en sorte que ls affiche sa sortie avec des couleurs en fonction du type de fichier ou de son extension. D'autres programmes sont capables d'améliorer leur affichage avec un peu de couleur.
C'est par exemple le cas de grep qui permet de filtrer un texte selon une expression rationnelle en mettant en avant les morceaux de texte correspondant au motif, c'est assez pratique lorsque l'on tente de déchiffrer un fichier de log ou tout autre fichier texte.
> tigrou@Lorien[192.168.0.243]:~$ cat .bashrc | egrep --color ' [a-z][a-z]='
Cette ligne permet d'obtenir tous les alias de 2 caractères. Ce qui donne dans mon terminal :
Pour que ce comportement soit systématique, il suffit d'ajouter les lignes suivante dans son fichier ~/.bashrc :
alias grep='grep --color=auto' alias egrep='egrep --color=auto'
Pour que tout appel à grep (et à egrep) mette en valeur le motif trouvé.
Suivre un fichier de log
tail est un programme qui propose d'afficher les n dernières lignes ou les n derniers octets d'un fichier. Il dispose d'une option -f (pour follow) très intéressante permettant de suivre un fichier pour faire défiler les dernières lignes ajoutées. Cette option combinée à d'autres utilitaires de traitement de texte (cut, sed, grep, ...) permet de suivre différents types de journaux facilement, deux exemples courants :
# suivre les logs d'Apache avec uniquement l'IP du visiteur, la page demandée, # son navigateur et le référent sans les requêtes pour les images et les feuilles de style tail -f access.log | egrep -v --line-buffered '(/var|/design|/share)' | cut -d ' ' -f 1,7,12- # suivre les logs de Postfix des mails rejetés # avec uniquement la raison du rejet tail -f mail.log | grep --line-buffered reject | cut -d ' ' -f 8-
À noter dans ces exemples, l'ajout du paramètre --line-buffered pour indiquer à grep de traiter les données ligne par ligne plutôt que par un buffer plus grand. Cette option permet de ne pas avoir de latence entre le moment ou tail écrit une nouvelle ligne et le moment ou grep la traite.
Être à l'aise avec bash #1
- Publié le 29 octobre 2006 à 16:36
- 5 commentaires
Bien que la plupart des distributions Linux et Ubuntu en particulier tendent à minimiser voire à rendre complètement inutile l'utilisation de la ligne de commande, il peut être intéressant de rendre cet outil un peu plus accueillant et facile d'utilisation. Pourquoi ? Si Xorg plante, c'est tout ce qui reste et puis pour certaines tâches, il n'y a pas plus rapide... Ce billet ouvre donc une série consacrée à la configuration et l'utilisation de bash.
Le prompt
Laurent - CyberSDF a publié un court billet présentant un outils en ligne permettant de créer un prompt plus fantaisiste que celui par défaut. Au delà de l'aspect purement esthétique, le prompt est la première chose que l'on voit lors de l'utilisation du shell, il peut donc mettre en valeur des informations importantes. Au travail ou à la maison, j'ai potentiellement accès en SSH à 13 machines différentes (3 Ubuntu, 9 Debian et une Solaris pour les curieux), et je suis fréquemment connecté à 3 ou 4 machines en même temps, le prompt doit donc m'indiquer sur quelle machine je suis et surtout avec quel login, pour cela j'utilise la configuration suivante soit dans le fichier /etc/bash.bashrc soit dans mon ~/.bashrc :
# couleurs C_RED="\[\e[1;31m\]" C_BLUE="\[\e[1;34m\]" C_GRAY="\[\e[1;30m\]" C_WHITE="\[\e[1;37m\]" C_YELLOW="\[\e[1;33m\]" C_DEF="\[\033[0m\]" mUID=`id -u` MACHINE="Lorien" IP="192.168.0.243" if [ "$mUID" = "0" ] ; then PS1="${C_YELLOW}>${C_DEF} ${C_RED}\u${C_DEF}@${MACHINE}${C_YELLOW}[${C_DEF}$IP${C_YELLOW}]${C_DEF}:\w${C_RED}#${C_DEF} " PS2="${C_RED}>${C_DEF} " else PS1="${C_YELLOW}>${C_DEF} ${C_BLUE}\u${C_DEF}@${MACHINE}${C_YELLOW}[${C_DEF}$IP${C_YELLOW}]${C_DEF}:\w${C_BLUE}\$ ${C_DEF}" PS2="${C_BLUE}>${C_DEF} " fi export PS2 export PS1
Cette configuration fait en sorte d'avoir un prompt bleu, jaune et blanc pour un utilisateur normal et rouge, jaune et blanc pour l'utilisateur root attirant ainsi mon attention sur le fait qu'en root, on ne tape par n'importe quoi... Il m'indique aussi le nom de la machine ainsi que son adresse IP. Ce qui donne :
Le titre des terminaux graphiques
De la même manière que le prompt, le titre des terminaux est très utile pour se repèrer lorsqu'on utilise Xorg. Dans un terminal, il est possible de changer ce titre de manière dynamique avec un simple echo, il suffit alors d'utiliser la variable PROMPT_COMMAND pour stocker une commande que le shell éxécutera à chaque affichage du prompt.
case $TERM in xterm*) PROMPT_COMMAND='echo -ne "\033]0;${USER}@${MACHINE}[$IP]: ${PWD}\007"' echo -ne "\033]0;${USER}@${MACHINE}[$IP]: ${PWD}\007" ;; *) setterm -blength 0 ;; esac
Avec ces quelques lignes, les terminaux affiche la même chose que le prompt dans leur titre (sans les couleurs) lorsque le type de terminal commence par "xterm" (ce qui est le cas avec xterm mais aussi gnome-terminal).
À noter que la seconde partie du case permet de supprimer le beep très énervant beep lorsqu'on est en console sans Xorg.
X11Forwarding : lancer une application sur un serveur et l'afficher ailleurs avec SSH
- Publié le 13 septembre 2006 à 00:15
- 0 commentaire
SSH est, comme l'indique la page du manuel du client ssh OpenSSH, un client permettant de s'identifier sur une machine distante et constitue un remplacement sécurisé (en tout cas crypté) de telnet et des utilitaires comme rsh ou rlogin qui s'appuient sur un identification par adresse IP ou pas mot de passe en clair. Une des particularités du protocole SSH est qu'il est prévu pour servir de transport à n'importe quel type de données. Cette application est appelée TCPForwarding et dans le cas d'application particulier de données "graphiques" cela s'appelle le X11Forwarding mais peut être utile pour faire circuler n'importe quelle informations de manière sûre ou pour faire des redirections de ports pour franchir un firewall par exemple.
X11Forwarding, quels intérêts ?
La possibilité d'afficher une application sur une machine différente de celle qui l'éxécute est déjà possible par X11 de manière native (avec un peu de configuration), alors pourquoi en rajouter une couche avec SSH ? Il y a plusieurs avantages à utiliser le X11Forwarding :
- tout comme telnet, les connections par le protocole X11 sont en clair (ie non cryptées) et donc par nature assez peu sécurisées.
- l'utilisation est simpliste et en configurant SSH pour utiliser l'authentification par échange de clés, on peut lancer une application distante quasiment comme une application locale.
- ssh dispose d'une option permettant de compresser les données échangées, ce qui peut grandement améliorer les performances sur des lignes à faible débit (mais les ralentir sur d'autres, à tester donc...)
Évidemment cette solution comporte quelques points faibles mais quelle solution n'en a pas ?
Configuration et utilisation
La mise en place de ce système est très simple. Sur le serveur sur lequel on va lancer les applications il faut installer OpenSSH (à l'aide d'apt-get sur un système Ubuntu ou Debian ou du votre système de paquets préféré) et configurer le daemon SSH en positionnant l'option X11Forwarding à yes dans le fichier de configuration /etc/ssh/sshd_config. Il ne faut évidemment par oublier de redémarrer le daemon ssh par :
tigrou@mon-server:~ $ sudo /etc/init.d/ssh restart
Une fois cette opération réalisée, on peut lancer des applications sur la machine distante et les afficher sur votre machine locale (ou sur une autre machine distante d'ailleurs) avec la ligne de commande suivante :
tigrou@machine-locale:~ $ ssh -c blowfish -X -C -f login@adresse ton_application
Explications : cette ligne indique à ssh de se connecter sur le serveur adresse "adresse" sous le login "login" pour y lancer ton_application.L'option -X indique que l'on souhaite utiliser le X11Forwarding ce qui signifie que ssh va installer toutes les variables d'environnements et faire toutes les opérations nécessaires pour cela.
Les autres options sont toutes facultatives. -C active la compression gzip qui peut ralentir ou accélèrer le lancement selon le débit (c'est à tester), -c blowfish indique à SSH d'utiliser un cryptage à l'aide de l'algorithme blowfish qui est normalement le plus performant. Enfin -f indique à SSH de passer en arrière plan une fois la commande lancée.
Après avoir tapé cette commande, par défaut ssh vous demandera votre mot de passe. Il est possible de s'authentifier uniquement à partir d'un système de clefs ou à partir d'une passphrase. Toutes ces possibilités sont détaillés dans la documentation SSH sur Ubuntu-fr et feront peut être l'objet d'un billet tant les options, les possibilités et les usages sont nombreux. Il faudra alors regarder du côté de ssh-agent, ssh-add et certainement x11-ssh-askpass...
