blog.roxing.net

Debian9 - Installation apache2 mariadb phpmyadmin & php7

Pierrox — 2017-12-04T21:20:52Z

apt install apache2 php7.0 logrotate mariadb-server phpmyadmin

A l'installation de phpmyadmin laisser le champ vide pour configurer automatiquement les identifiants de connexion à la base de données.

[x] Cocher redémarrer apache2 pour prendre en compte la configuration ;

Puis ajouter "root" en superadmin de phpmyadmin

mysql -uroot mysql -e "SET PASSWORD FOR 'root'@'localhost' = PASSWORD('MonPassRootIci'); update user set plugin='' where user='root'; flush privileges;"

Se connecter sur http://localhost/phpmyadmin

Compresser, découper et envoyer des fichiers volumineux sous Linux

Pierrox — 2016-11-22T09:59:03Z

Xz - Compresser un fichier

Xz est un outil de compression très performant. Pour compresser un gros fichier avec le taux de compression maximal on utilise simplement :

xz -9 gros_fichier

Le fichier de sortie sera nommé gros_fichier.xz

Split - Découper un fichier en plusieurs fichiers de taille définie

Découper le fichier en plusieurs fragments de 1GB (-b bytes) et ajouter un suffixe numérique aux fichiers de sortie (-d )

split -b 1024M -d gros_fichier.xz gros_fichier.xz_part
donnera :

gros_fichier.xz_part01
gros_fichier.xz_part02
gros_fichier.xz_part03
...

Combiner tar + xz-utils + split

A titre d'exemple, le même résultat que précédement, en utilisant conjointement tar et split :

tar -Jcvf - un_repertoire_ou_fichier | split -d -b 1024MB - gros_fichier.tar.xz.

Tmux - Envoyer les fichiers en tâche de fond

Pour envoyer les fichiers vers un serveur, j'utilise scp avec une clef ssh et comme je ne veux pas saturer la connexion j'utilise l'option -l (limit). Dans l'exemple ci-dessous, -l 512 correspond à environ 50ko/s.

scp -i ~/.ssh/ma_clef -l 512 gros_fichier.xz_part* user@host:/home/bob/incoming

C'est bien joli, mais si je fais des transferts à distance, j'aimerais bien lancer la commande en tâche de fond, surtout si l'upload est très long.
Pour ce faire, j'utilise tmux qui permet d'utiliser plusieurs terminaux virtuel que l'on peu détacher ou rattacher au terminal facilement.

tmux new-session -d -s upload 'scp -i ~/.ssh/ma_clef -l 512 gros_fichier.xz_part* user@host:/home/bob/incoming 2> errors.log'

Rattacher le terminal pour voir l'upload en cours : tmux attach
Détacher le terminal avec la combinaison de touches ctrl + b puis d
Grâce à tmux, je peux me déconnecter du shell distant et revenir plus tard...
Un simple tmux a me permettra de consulter l'état d'avancement de l'upload.

Cat - Réassembler les fichiers découpés

Une fois les fichiers transférés, je les réassemble avec un simple cat

cat gros_fichier.xz_part* > gros_fichier.xz

Décompression d'un xz ou d'un tar.xz

Avec tar (-x xtract) :
tar -Jxvf gros_fichier.tar.xz

Avec xz-utils (-d)
xz -d gros_fichier.xz

Voilà.

[Debian] Java JRE 8 - Installation et Mises à jour

Pierrox — 2016-04-07T05:00:00Z

Installation de java-package

java-package est un script permettant de générer un paquet # !Debian afin de faciliter l'installation et la mise à jour de l'Environnement d'exécution Java (JRE).

Récupérer java-package et les outils nécessaires à la génération du paquet :

apt-get install java-package build-essential java-common

Récupérer l'archive sur le site d'Oracle ©

Rendez vous sur le site d'Oracle© afin de télécharger les archives.

Bien récupérer les archives en tar.gz sinon le script de génération du paquet ne fonctionnera pas !

On peux également récupérer les archives via WGET ou CURL (Et passer outre l'acceptation de la licence...)

Exemple de commande CURL pour récupérer java 8.77 32BIT via le terminal

curl -v -j -k -L -H "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u77-b03/jre-8u77-linux-i586.tar.gz > jre-8u77-linux-i586.tar.gz

Exemple de Commande WGET pour récupérer java 8.77 64BIT via le terminal

 wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u77-b03/jre-8u77-linux-x64.tar.gz

Générer le paquet java JRE 8 pour votre distribution Debian

une fois l'archive téléchargée il suffit d'exécuter le script make-jpkg sous l'identifiant utilisateur :

fakeroot make-jpkg jre-8u77-linux-i586.tar.gz

qui devrait démarrer ainsi :

Detected Debian build architecture: i386 Detected Debian GNU type: i586-linux-gnu Detected product: Java(TM) Runtime Environment (JRE) Standard Edition, Version 8 Update 77 Oracle(TM) Is this correct [Y/n]: y <- Checking free diskspace: done. In the next step, the binary file will be extracted. Probably a license agreement will be displayed. Please read this agreement carefully. If you do not agree to the displayed license terms, the package will not be built. Press [Return] to continue: Testing extracted archive... okay.

Une fois le script terminé l'installation du nouveau paquet se fait via la commande dpkg :

dpkg -i oracle-java8-jre_8u77_i386.deb

Et voilà ! L'environnement d'exécution java et désormais opérationnel !

Voir en ligne : Téléchagement Java sur le site d'Oracle©.

La procédure reste la même pour l'installation de Java SE Development Kit 8u77 seul les liens et noms de fichiers sont à remplacer.

LXC root password

Pierrox — 2015-09-10T07:36:08Z

Pour changer le mot de passe sans avoir à se connecter au container LXC, Il faut “chrooter” son système de fichier (chroot est disponible dans les paquets coreutils de Debian) .

“Chrooter” le système de fichier du container LXC “NomContainer” :

root@pierrox-laptop:# chroot /var/lib/lxc/NomContainer/rootfs

Générer un nouveau mot de passe root pour le container LXC :

root@pierrox-laptop:# passwd
Enter new UNIX password: Retype new UNIX password: passwd: password updated successfully

Quitter l'environement "chrooté" :

root@pierrox-laptop:# exit

Attention, si vous utilisez un shell différent de bash tel que zsh, il se peut que vous vous trouviez confronté à cette erreur :
« chroot : impossible d'exécuter la commande « /bin/zsh » : Aucun fichier ou dossier de ce type ».

dans ce cas :

root@pierrox-laptop:# /usr/sbin/chroot /var/lib/NomContainer/rootfs /bin/bash

devrait permettre de chrooter le container lxc.

LXC Debian Jessie

Pierrox — 2015-09-05T21:54:48Z

Installation de LXC

apt-get install lxc lxctl

Création d'un container

lxc-create -n NomContainer -t debian

– -n nom du container
– -t template de l'OS à utiliser

Bien noter le mot de passe root qui s'affichera à la fin de la création du container lxc.

Configuration du réseau sur l'hôte

Il y a plusieurs façons de configurer le réseau, pour ma part je préfère créer un (ou plusieurs) sous-réseaux pour mes containers qui seront "natter" par la machine hôte.
Pour illustrer, on pourrait dire que les sous-réseaux sont cloisonnés à l'intérieur de l'hôte qui fera office de pare-feu vers l'extérieur.

Autoriser "l'ip forwarding"

nano /etc/sysctl.conf net.ipv4.ip_forward=1

Recharger la configuration du système pour prendre en compte la modification.

sysctl -p

Configurer l'interface qui servira de bridge

La paquet bridge-utils est nécessaire, il est normalement installé en dépendance de lxc, au cas ou :

apt-get install bridge-utils

Paramétrage de /etc/network/interfaces

# The loopback network interface auto lo iface lo inet loopback # Configuration du Bridge pour le sous réseau virtualisé auto br0 iface br0 inet static address 192.168.100.254 netmask 255.255.255.0 bridge_ports none

Redémarrer le service réseau afin de prendre en compte la nouvelle interface br0

service networking restart

Vérifier que l'interface réseau est bien présente :
ifconfig devrait renvoyer quelque chose comme ça

br0 Link encap:Ethernet HWaddr 22:ce:06:00:1d:7f inet adr:192.168.100.254 Bcast:192.168.100.255 Masque:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:24 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 lg file transmission:0 RX bytes:0 (0.0 B) TX bytes:3915 (3.8 KiB)

Activer le partage de connexion internet pour les containers LXC :

On va donner l'accès internet aux containers LXC à travers wlan0 (On verra comment automatiser ça sur un hôte au profil itinérant qui se connecte sur des interfaces diverses et variées : wlan0 eth0 usb0... )

iptables -t nat -F POSTROUTING iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE

Configuration du réseau sur les containers LXC

Attention ! il ne s'agit pas de paramétrer le réseau à l'intérieur du container mais d'éditer un fichier de configuration qui se chargera de configurer le réseau au démarrage de celui-ci.

Par défaut, Debian installe les nouveaux containers dans /var/lib/lxc ; ce dossier contient tous les containers créés, qui eux-même contiennent des fichiers de logs, de configs et le dossier rootfs qui comme son nom l'indique, correspond à la racine du système virtualisé ( / ).

Afin de configurer le réseau sur notre container LXC, nous allons éditer son fichier de config /var/lib/lxc/NomContainer
Extrait de la configuration réseau d'un container /var/lib/lxc/NomContainer/config

lxc.network.type = veth lxc.network.name = veth0 lxc.network.flags = up lxc.network.link = br0 lxc.network.veth.pair = veth0 lxc.network.ipv4 = 192.168.100.1/24 lxc.network.ipv4.gateway = 192.168.100.254

Démarrage du container et test du réseau

lxc-start -n NomContainer -d

– -n nom du container
– -d en mode daemon

La commande pour contrôler si notre container LXC est bien démarré :

lxc-ls -f

Devrait retourner

NAME STATE IPV4 IPV6 AUTOSTART --------------------------------------------------------- NomContainer RUNNING 192.168.100.1 - NO

Sur l'hôte un petit ping 192.168.100.1 devrait retourner :

PING 192.168.100.1 (192.168.100.1) 56(84) bytes of data. 64 bytes from 192.168.100.1: icmp_seq=1 ttl=64 time=0.087 ms

On va se connecter directement au container LXC

lxc-console -n NomContainer

Se connecter au container, j'espère que vous avez bien noté le mot de passe root lors de sa création sinon vous pouvez toujours consulter l'article dédié au changement de mot de passe root d'un container LXC.
Une fois connecté, on va tester l'accès internet en utilisant apt pour installer ping afin de "pinguer" la machine hôte :

root@NomContainer:~#apt-get install inetutils-ping Les NOUVEAUX paquets suivants seront installés : inetutils-ping (...) Paramétrage de inetutils-ping (2:1.9.2.39.3a460-3) .. root@NomContainer:~#ping 192.168.100.254 PING 192.168.100.254 (192.168.100.254): 56 data bytes 64 bytes from 192.168.100.254: icmp_seq=0 ttl=64 time=0,163 ms 64 bytes from 192.168.100.254: icmp_seq=1 ttl=64 time=0,163 ms

Et voilà, Juste ça marche !

Pour quitter un container, utilisez la combinaison de touche ctrl+a puis q

[BASH] Liste des variables

Pierrox — 2015-02-14T12:53:41Z

Manipulation de variables simples

`var=val` `var="a b"`	affectation de la variable "var"
`$var` `${var}`	contenu de la variable "var"
`${#var}`	longueur de la variable "var"
`${var:-valeur}`	affectation conditionnelle, si "var" non défini alors var = valeur
`export var` `declare -x var`	exportation de la variable "var" vers les shells fils
`set`	affichage de l'ensemble des variables définies dans le shell
`unset var`	suppression de la variable "var"

Tableaux

`tab[0]=val`	affectation du premier enregistrement du tableau "tab"
`${tab[0]}` `$tab`	contenu du premier enregistrement du tableau "tab"
`${tab[11]}`	contenu du douzième enregistrement du tableau "tab"
`${tab[*]}`	ensemble des enregistrements du tableau "tab"
`${#tab[11]}`	longueur du douzième enregistrement du tableau "tab"
`${#tab[*]}`	nombre d'enregistrements du tableau "tab"
`${!tab[@]}`	liste des clefs ( Index ) du tableau "tab"

Paramètres positionnels et arguments

`$0`	nom du script
`$1` `$2` ... `${10}`	paramètres positionnels (1, 2 et 10)
`$#`	nombre de paramètres positionnels
`$*` `$@`	ensemble des paramètres positionnels, équivalant à $1 $2 ... $n

Variables spéciales

`$$`	PID du shell courant
`$!`	PID du dernier travail lancé en arrière plan
`$?`	code retour de la dernière commande
`${PIPESTATUS[0]}`	code retour de la première commande d'un pipe

Variables d'environnement

`$HOME`	chemin du répertoire personnel de l'utilisateur
`$OLDPWD`	chemin du répertoire précédent
`$PATH`	liste des chemins de recherche des commandes exécutables
`$PPID`	PID du processus père du shell
`$PS1`	invite principale du shell
`$PS2`	invite secondaire du shell
`$PS3`	invite de la structure shell "select"
`$PS4`	invite de l'option shell de débogage "xtrace"
`$PWD`	chemin du répertoire courant
`$RANDOM`	nombre entier aléatoire compris entre 0 et 32767
`$REPLY`	variable par défaut de la commande "read" et de la structure shell "select"
`$SECONDS`	nombre de secondes écoulées depuis le lancement du shell

Linux Mysql - Sauvegarde & compression

Pierrox — 2015-02-12T10:58:26Z

su -c "mysqldump -u$user-p$password $mydatabase | bzip2 > /$mypath/<code class='spip_code spip_code_inline' dir='ltr'>date +%F-%H%M</code>_$output.sql.bz2" $user

Sauvegarder toute la base en concaténant le nom de l'hostname + la date pour le nom du fichier de sauvegarde :

mysqldump -u$user -p$password --all-database | bzip2 > $(date +%F-%H%M)-$(hostname -A).tar.bz2

En théorie la commande ci-dessus devrait fonctionner sans problème.
J'ai eu un bug ? sur ma debian, avec le résultat de la commande de hostname -a qui me renvoyait systématique un espace en fin de chaîne.

Je vous laisse apprécier la basherie ci-dessous visant a nommer le fichier de sortie en supprimant l'espace indisposant avec la commande sed.

mysqldump -u$user-p$pass --all-databases | bzip2 > $(echo "$(date +%F-%H%M)-$(hostname -A)" | sed 's/ //g').sql.bz2

Pour importer une sauvegarde Mysql au format bz2 sans faire une décompression préalable.

bunzip2 < dump.sql.bz2 | mysql -uuser -ppass database

Compiler un kernel pour LXC

Pierrox — 2013-06-20T14:24:36Z

Récupérer les sources du noyau, le patch grsec et la config ovh qui va bien

Se rendre dans un dossier de travail

cd /usr/src

Téléchargement du kernel

wget ftp://ftp.kernel.org/pub/linux/kernel/v3.x/linux-3.9.6.tar.xz

Téléchargement du patch grsecurity [1] correspondant à la version du noyau (3.9.6 dans l'article)

wget https://raw.github.com/slashbeast/grsecurity-scrape/master/test/grsecurity-2.9.1-3.9.6-201306182033.patch

récuperer la config du noyaux ovh sur leur serveur ftp [2]

wget ftp://ftp.ovh.net/made-in-ovh/bzImage/latest-production/config-3.8.13-xxxx-grs-ipv6-64

Préparer les sources

décompresser [3] le noyau

tar -Jxf linux-3.9.6.tar.xz

copier la configuration ovh dans racine du noyau linux décompressé précédemment

cp config-3.8.13-xxxx-grs-ipv6-64 linux-3.9.6

aller dans le répertoire du noyau fraichement décompressé

cd linux-3.9.6

appliquer le patch grsec

patch -p1 < ../grsecurity-2.9.1-3.9.6-201306182033.patch

Configuration des cgroups

dans le repertoire du kernel, lancer l'utilitaire de configuration du noyau make menuconfig et configurer lxc cgroup [4] en activant les options suivantes :

-> General setup [renommer votre kernel] Local version - append to kernel release -> Control Group support [x] Namespace cgroup subsystem [x] Freezer cgroup subsystem [x] Cpuset support [x] Simple CPU accounting cgroup subsystem [x] Resource counters [x] Memory resource controllers for Control Groups -> Group CPU scheduler [x] Basis for grouping tasks (Control Groups) (!) [x] Group scheduling for SCHED_OTHER (NEW) [x] CPU bandwidth provisioning for FAIR_GROUP_SCHED [x] Group scheduling for SCHED_RR/FIFO -> Namespaces support [x] UTS namespace [x] IPC namespace [x] User namespace (!) [x] Pid namespace [x] Network namespace -> Device Drivers -> Character devices [x] Support multiple instances of devpts [*] Unix98 PTY support -> Network device support [x] MAC-VLAN support [x] Virtual ethernet pair device -> Networking support -> Networking options [x] 802.1d Ethernet Bridging [x] Network priority cgroup -> Security options [x] File POSIX Capabilities (!)

(!) suivant la version/configuration du kernel certaines options peuvent être déplacées ou inexistantes. Pour activer l'option usernamespace je suis tombé sur un bug pour le noyau 3.8. De plus une contrainte oblige a désactiver le système de fichier XFS [5] pour pouvoir activer cette option. XFS devrait être supporté à partir des versions 3.10 du kernel linux.

Une fois votre configuration terminée, retourner sur la page d'accueil de menuconfig sélectionner < Exit >, une boite de dialogue vous demande d'enregistrer votre configuration selectionner < yes > avant de quitter.

Avant de compiler, On va tester la configuration :

 CONFIG=/usr/src/linux-3.9.6/.config lxc-checkconfig --- Namespaces --- Namespaces: enabled Utsname namespace: enabled Ipc namespace: enabled Pid namespace: enabled User namespace: enabled Network namespace: enabled Multiple /dev/pts instances: enabled --- Control groups --- Cgroup: enabled Cgroup clone_children flag: enabled Cgroup device: enabled Cgroup sched: enabled Cgroup cpu account: enabled Cgroup memory controller: missing (!) Cgroup cpuset: enabled --- Misc --- Veth pair device: enabled Macvlan: enabled Vlan: enabled File capabilities: enabled

Cgroup memory controller : missing (!) - Debian Wheezy

Sur Debian wheezy, avec le paquet lxc, la configuration de "memory controller" semble manquante. En installant la dernière version de lxc (0.9) la vérification devient OK

Youpi ! la configuration est maintenant terminée, il est temps de lancer la compilation avant de boire un café !

Compilation du noyau

Penser à installer les outils pour la compilation des noyaux. Sur Debian, le paquet s'appelle build-essential c'est un meta-paquet dédié a l'installation de tous les outils de compilation make, gcc, etc..

Lancer la compilation, ou -j X (correspond au nombre de core ) :

make -j 8

Le kernel se retrouve dans le dossier arch/x86/boot. On va Copier/renommer le nouveau kernel dans le dossier /boot du système :

cp arch/x86/boot/bzImage /boot/bzImage-3.9.6-xxxx-grs-ipv6-64-lxc

Installer le kernel et redémarrer

Je vous invite à consulter mon article précédent intitulé Installer un nouveau kernel Linux en 5 étapes

[1] tous les patchs Grsec sur github

[2] Tous les noyaux ovh ftp://ftp.ovh.net/made-in-ovh/bzImage

[3] package xz-utils sur debian et consorts

[4] d'aprés la page du wiki de lxc sur le sourceforge officiel

[5] bug 917708 de compatibilité

Configuration du kernel réalisé à partir de http://lxc.sourceforge.net/man/lxc.html

Installer un kernel linux en 5 étapes

Pierrox — 2013-05-17T02:44:19Z

1 - Mettre le nouveau kernel linux super optimisé dans le dossier /boot

wget http://mon.super.kernel.com/bzimage-superkernel /boot

2 - Editer Le fichier de "pré-configuration" personnalisé pour Grub2

nano /etc/grub.d/40_custom

Et ajouter une entrée en s'inspirant de /boot/grub/grub.cfg (notamment pour les uuid) pour votre tout nouveau kernel

menuentry "Super Kernel" { insmod part_msdos insmod ext2 set root='(hd0,msdos1)' search --no-floppy --fs-uuid --set 698e9aea-42f5-4c38-adc5-a34a4b7c0c11 linux /boot/bzimage-superkernel root=/dev/sda1 ro quiet }

3 - Forcer Grub à utiliser le Super Kernel par défaut

nano /etc/default/grub

repérer la ligne GRUB_DEFAULT="1", sinon l'ajouter.

Modifier par le nom du "menuentry" créé précédemment.

GRUB_DEFAULT="Super Kernel"

4 - Régénérer le fichier de config de Grub2

grub-mkconfig -o /boot/grub/grub.cfg