Appel au traducteur pour CalcPvAutonome (calculateur photovoltaïque autonome)

Edit 27/01/18 : Merci à tous, c’est bon nous sommes à 100% !

Je recherche des traducteurs Français > Anglais pour CalcPvAutonome. Plateforme de traduction : crwd.in/calcpvautonome

Petit rappel : CalcPvAutonome est un logiciel libre (licence Beerware) et gratuit de dimensionnement d’installation électrique solaire en site isolé (autonome). Il se veut transparent (dans la méthode), pédagogique et surtout détaché de toute structure commercial.

Suite à mon dernier article à son sujet, CalcPvAutonome à fait beaucoup de chemin. Au départ, il ne savait pas récupéré les données d’ensoleillement au delà de la France métropolitaine. Devant le nombre de demande extérieur à la France, j’ai pris mon clavier et maintenant j’utilise les données d’ensoleillement du projet PVGIS qui permet désormais à CalcPvAutnome d’aller de couvrir une bonne partie du globe. De ce fait je lance un appel au contributeur traducteur pour m’aider à traduire ce logiciel vers l’anglais. Une fois que ça sera fait, je passerai le logiciel en anglais natif et j’ouvrirai la traduction à toutes les langues du monde (rien que ça)

La plateforme de traduction collaborative est par ici : crwd.in/calcpvautonome

D’avance merci pour vos coups de mains / claviers…

Script API Ispconfig création utilisateur

Je m’occupe d’un service d’hébergement destiné aux actions politiques / citoyennes / artistiques… Le serveur était plein de chez plein, ça tournait sans que je m’en occupe trop… J’ai décroché de ces geekeries pour d’autres occupations… Mais voilà Debian 7 était en fin de support, j’ai migré, fais du ménage… du coup il y a de nouveau de la place sur le serveur donc je ré-ouvre les portes.

De ce fait j’ai automatisé une tâche qui me prenait du temps jadis : la création des comptes (même si avec Ispconfig, c’est quand même clique clique). J’ai donc accouché d’un script PHP qui utilise l’API d’ISPconfig, on y passe en paramètre :

  • Nom d’utilisateur
  • Email de l’utilisateur
  • Sous domaine souhaité (ici : cequejesouhait.zici.fr)

Et il nous génère :

  • Création de l’utilisateur « client » pour l’accès au panel Ispconfig
  • Création du site web
    • Création d’une base de donnée et de son utilisateur
    • Création d’un compte FTP et SFTP pour l’accès au site web
  • Création d’un transfère mail (ici cequejesouhait@zici.fr vers l’email de l’utilisateur)

Le script est téléchargeable ici.

Firewall : Mon script iptables

Je partage ici mon script de firewall iptable. C’est un script « à l’ancienne », dans du bash… ça fait le taf, mais rien de bien transsudant. En gros :

  • On ferme tout les ports sauf ceux qui nous intéresse (80, 25, icmp…)
  • Petite fonction pour ouvrir les ports mis en écoute sur Portsentry. Portsentry c’est un petit logiciel de sécurité en mode « pot de miel ». On met des ports en écoute mais il n’y a rien derrière. Dès que quelqu’un tente de s’y connecter (un robot ou quelqu’un de malveillant), ça bloque son IP dans le firewall pour un temps donnée. C’est radical si vous déplacez le port SSH du 22 vers autre chose et que vous mettez Portsentry à écouter (entre autre) sur le 22…
  • Mode maintenance du serveur web (lancé via ./iptables.sh maintenance). Il permet de mettre une page de maintenance pour tout le monde sauf pour vous (j’explique en détail dans cet article)
#!/bin/bash

## IP :
# Chez moi
MOI="A.A.A.A" 
# Mon serveur
SRV1="X.X.X.X"

IPT="/sbin/iptables"
PORTSENTRYCONF="/etc/portsentry/portsentry.conf"

export IPT PORTSENTRYCONF

function portsentryOpen() {
	. ${PORTSENTRYCONF}
	IFS=',' read -ra TCP_PORTS_SPLIT <<< "${TCP_PORTS}"
	for TCP_PORT in "${TCP_PORTS_SPLIT[@]}"; do 
		${IPT} -A INPUT -p tcp --dport ${TCP_PORT} -j ACCEPT
	done
	IFS=',' read -ra UDP_PORTS_SPLIT <<< "${UDP_PORTS}"
	for UDP_PORT in "${UDP_PORTS_SPLIT[@]}"; do 
		${IPT} -A INPUT -p udp --dport ${UDP_PORT} -j ACCEPT
	done
}

# Remise a 0
${IPT} -F
${IPT} -t nat -F

# Les connexions entrantes sont bloquées par défaut
${IPT} -P INPUT DROP
# Les connexions destinées à être routées sont acceptées par défaut
${IPT} -P FORWARD ACCEPT
# Les connexions sortantes sont acceptées par défaut
${IPT} -P OUTPUT ACCEPT


######################
# Règles de filtrage #
######################
# Nous précisons ici des règles spécifiques pour les paquets vérifiant
# certaines conditions.
 
# Pas de filtrage sur l'interface de "loopback"
${IPT} -A INPUT -i lo -j ACCEPT
 
# Accepter le protocole ICMP (notamment le ping)
${IPT} -A INPUT -p icmp -j ACCEPT
  
# Accepter les packets entrants relatifs à des connexions déjà
# établies : cela va plus vite que de devoir réexaminer toutes
# les règles pour chaque paquet.
${IPT} -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# ftp 
${IPT} -A INPUT -p tcp --dport 20 -j ACCEPT 
${IPT} -A INPUT -p tcp --dport 21 -j ACCEPT
# Préalabielemnt, pour pure-ftpd : echo "29700 29750" > /etc/pure-ftpd/conf/PassivePortRange ${IPT} -A INPUT -p tcp --dport 29700:29750 -j ACCEPT
# SSH
${IPT} -A INPUT -p tcp --dport 222 -j ACCEPT
# NTP
${IPT} -A INPUT -p udp --dport 123 -j ACCEPT
# smtp
${IPT} -A INPUT -p tcp --dport smtp -j ACCEPT
# Pour test bricolage smtp
${IPT} -A INPUT -p tcp --dport 587 -j ACCEPT
# imap(s)
${IPT} -A INPUT -p tcp --dport 143 -j ACCEPT
${IPT} -A INPUT -p tcp --dport 993 -j ACCEPT
# sieve
${IPT} -A INPUT -p tcp --dport 4190 -j ACCEPT
# dns
${IPT} -A INPUT -p tcp --dport domain -j ACCEPT
${IPT} -A INPUT -p udp --dport domain -j ACCEPT
# http
${IPT} -A INPUT -p tcp --dport http -j ACCEPT
# https
${IPT} -A INPUT -p tcp --dport https -j ACCEPT

# Maintenance 
if [ "$1" == "maintenance" ] ; then
	echo "Maintenance On"
	/usr/sbin/service lighttpd start
	${IPT} -A INPUT -p tcp --dport 81 -j ACCEPT
	${IPT} -t nat -A PREROUTING \! -s ${MOI} -p tcp --dport 80 -j DNAT --to-destination ${SRV1}:81
	${IPT} -t nat -A POSTROUTING -j MASQUERADE
elif [ -f "/var/run/lighttpd.pid" ] ; then
	echo "Maintenance Off"
	/usr/sbin/service lighttpd stop
fi

# Portsentry 
if [ -f ${PORTSENTRYCONF} ] ; then
	portsentryOpen ${IPT} ${PORTSENTRYCONF}
fi

# End
${IPT} -A INPUT -j LOG --log-prefix "iptables denied: "  --log-level 4
${IPT} -A INPUT -j REJECT

# Si vous utilisez fail2ban, relancé à la fin du script :
#/usr/sbin/service fail2ban restart

 

 

 

CalcPvAutonome : Outil de dimensionnement pour une installation photovoltaïque en site isolé (autonome)

Pour réaliser mon installation photovoltaïque autonome, je me suis fait aider sur forum-photovoltaique.fr (dans la rubrique dédiée). Depuis, j’y traîne de temps en temps pour aider à mon tour. Sur le forum, je me suis aperçu rapidement qu’on faisait très souvent la même chose : du dimensionnement. Il n’y avait (à ma connaissance) pas d’outil pour aider à faire du dimensionnement pour site isolé qui soit indépendant (des outils pour au final vendre un kit qui va marcher 2 ans, ça oui, il y a en a…)

Donc je me suis dit, je vais le faire… Alors voilà le premier jet :

Les critères étaient donc :

  • Logiciel libre : les méthodes de calcul étant nombreuses, je me suis dit que la collaboration de chacun était souhaitable ;
  • Indépendant : pas de site marchand, rien à vendre à la fin ;
  • Pédagogique : pour ceux qui veulent comprendre les calculs ;
  • Utilisable à plusieurs niveaux :
    • Niveau débutant : on demande pas grand chose, beaucoup de calculs sont automatiques, déduits ;
    • Niveau pro : on peut personnaliser plus de paramètres ;

Je suis à la recherche de (petits) contributeurs à ce (petit) projet pour :

  • Discuter de la méthode de calcul ;
  • Distribuer des suggestions, des critiques constructives ;
  • Des idées pour aller plus loin… Pour l’instant j’ai listé :
    • Gérer d’autres technologies de batterie que AGM/plomb
    • Faire des hypothèses de câblage de PV
    • Générer un beau dessin de câblage final
    • Récupérer la valeur rayonnement moyen quotidien automatiquement…)
  • Dire que les couleurs piquent les yeux ;
  • Le mieux ça serait des doigts pour co-coder ;

Fonctionnalités de CalcPvAutonome

Pour l’utilisateur de base :

  • 3 modes au formulaire (Débutant, Éclairé, Expert)
  • Pour déterminer ses besoins électriques journaliers, un tableau dynamique dédié : CalcConsommation
  • Pour déterminer l’ensoleillement :
    • (simple) Carte par zone – simple mais approximatif
    • (précis) Valeur du site http://ines.solaire.free.fr/gisesol_1.php (kWh/m²/j)
  • En mode expert, ajuster le degré de décharge, les valeurs de rendement électrique des batteries ou du reste de l’installation,
  • Déduction automatique de la tension du parc de batteries à utiliser (possibilité de forcer une valeur en mode expert)
  • Déduction automatique d’une configuration du parc de câblage des batteries et du modèle à utiliser (exemple : « 2 batteries 220Ah 12V en série ») (possibilité de forcer un modèle de travail en mode expert)
  • Estimation d’une fourchette du coût du parc de batteries & photovoltaïque
  • Explication détaillée du calcul pour parvenir au résultat

Pour les utilisateurs avancés :

  • Intégration sur votre site web
  • Modification possible du fichier config.ini pour changer :
    • Les valeurs par défaut du formulaire
    • Les valeurs d’irradiation de la carte par zone
    • La fourchette de prix des panneaux photovoltaïques et des batteries
    • Les modèles de batteries possibles pour la détermination d’une configuration

PvMonit – Monitoring de mon installation photovoltaïque autonome

Nouvel article avec nouvelle version de PvMonit ici même + gestion du surplus électrique

Cet article fait suite à la réalisation de mon installation électrique solaire autonome. Je suis très content de celle-ci, seulement j’ai un grand besoin de maîtrise, et ne pas savoir tout ce qui se passait dans ces petites boîtes bleues me taraudait… Il fallait que je monitor. Coup de chance, les appareils Victron que j’ai installés peuvent se connecter à un ordinateur avec les câbles VE Direct USB.

En bon libriste que je suis, j’ai vite découvert OpenEnergyMonitor project. J’ai failli craquer pour un emonPi – Solar PV mais ça ne correspondait pas complètement à mes contraintes. J’ai donc pris mes petits doigts et j’ai pondu PvMonit.

PvMonit C’est quoi ?

PvMonit c’est donc un petit logiciel de monitoring photovoltaïque pour matériel Victron compatible Ve.direct (USB), particulièrement adapté pour les installations autonomes. Il permet une vue « en direct » et un export de l’historique vers emoncms (une branche d’OpenEnergyMonitor project).

Exemple d’usage de PvMonit (le mien) : je dispose d’un RaspberryPi (mini ordinateur qui ne consomme que ~3W), mes appareils Victron (MPTT, BMV) sont connectés avec des câbles VE.Direct USB. PvMonit est installé sur ce RaspberryPi et me permet :

  • D’afficher les informations en temps réel sur une page web (local)
    • Une copie de cette page est faite toutes les heures (si la connexion internet est allumée) et est accessible ici : http://demo.zici.fr/PvMonit/
  • De collecter les données toutes les X minutes et les expédier vers emoncms quand internet est là (le wifi n’étant pas toujours allumé)

Des images :

Installation de PvMonit

Le matériel

Il vous faudra pour suivre ce tuto :

  • Un ordinateur faible consommation configuré sous Debian ou un dérivé type Ubuntu/Raspbian (j’ai fait un article sur l’installation de mon Raspberry PI) 68€ (d’occasion avec coque, ventilateur, carte SD)
  • Les câbles Ve.Direct USB connectés à vos appareils 30€ (x3 car 3 appareils à connecter)
  • En option :
    • Une sonde de température USB pour contrôler la température du local où vivent les batteries. J’utilise « thermomètre USB TEMPer » qui coûte entre 5 et 20€, (ils en parlent ici)
    • Une pince ampèremètre USB pour contrôler la consommation de l’habitat. J’utilise la Aviosys 8870 à 27€ quand même, mais il ne semble pas y avoir beaucoup de concurrence pour ce type de produit… (j’en parle ici)

Voici le schéma de mon installation avec le câblage pour PvMonit incorporé :

pvmonit-cablage

Et voilà dans la vraie vie :

Le logiciel : Installation de PvMonit

Requis

  • Linux (le tutoriel ci-dessous est prévu pour Debian/Rasbian/Ubuntu like)
  • PHP (5.6 minimum)
  • Lighttpd/Apache (ou autre serveur web)
  • Perl
  • Python

Installation

PvMonit dispose de deux fonctions dissociées et indépendantes que je vais distinguer :

  • Interface en temps réel
  • Export vers emoncms

Il y a bien sûr une base commune :

La base / le socle

Installation de PvMonit via le dépôt git et de ses dépendances :

aptitude install php-cli git python-serial sudo
cd /opt
git clone https://github.com/kepon85/PvMonit.git
cp config-default.php config.php

Vous pouvez maintenant éditer le fichier config.php à votre guise !

Test du script vedirect.py : branchez un appareil Victron avec un Câble Ve.Direct USB et voici un exemple de ce que vous devriez obtenir (Ici un MPTT BlueSolare branché sur le ttyUS0)

$ /opt/PvMonit/bin/vedirect.py /dev/ttyUSB0 
PID:0xA04A
FW:119
SER#:HQ********
V:25660
I:500
VPV:53270
PPV:14
CS:3
ERR:0
LOAD:ON
H19:3348
H20:1
H21:17
H22:33
H23:167
HSDS:52

Pour comprendre chaque valeur, téléchargez la documentation Victron VE Direct Protocol documentation : https://www.victronenergy.fr/support-and-downloads/whitepapers

Interface web en temps réel

Installation des dépendances :

aptitude install lighttpd php-cgi 
lighttpd-enable-mod fastcgi
lighttpd-enable-mod fastcgi-php

Configuration du serveur http, avec le fichier /etc/lighttpd/lighttpd.conf :

server.document-root        = "/opt/PvMonit/www"
server.pid-file             = "/var/run/lighttpd.pid"
server.username             = "www-data"
server.groupname            = "www-data"
server.port                 = 80
index-file.names            = ( "index.html", "index.php")
url.access-deny             = ( "~", ".inc" )
include_shell "/usr/share/lighttpd/use-ipv6.pl " + server.port
include_shell "/usr/share/lighttpd/create-mime.assign.pl"
include_shell "/usr/share/lighttpd/include-conf-enabled.pl"

On applique la configuration :

service lighttpd restart

On ajoute ensuite la possibilité à l’utilisateur exécutant lighttpd de lancer les script avec sudo sans mot de passe :

Lancer la commande :

visudo

Ajouter la ligne suivante :

+ www-data ALL=(ALL) NOPASSWD: /usr/bin/perl /opt/PvMonit/bin/ampermetre.pl, /opt/temperv14/temperv14 -c, /usr/bin/python /opt/PvMonit/bin/vedirect.py /dev/tty*

C’est terminé, vous pouvez vous connecter sur votre IP local pour joindre votre serveur web :

Export vers emoncms

Connectez-vous à votre interface emoncms hébergée ou créez un compte sur emoncms.org et rendez-vous sur la page « Input api » https://emoncms.org/input/api :

emoncms_api

Récupérez la valeur « Accès en écriture » et ajoutez-la dans le fichier de configuration Pvmonit /opt/PvMonit/config.php :

- $EMONCMS_URL_INPUT_JSON_POST='https://emoncms.chezvous.org/input/post.json';
- $EMONCMS_API_KEY='XXXXXXXXXXXXXXXXXXXXXXXX';
+ $EMONCMS_URL_INPUT_JSON_POST='https://emoncms.org/input/post.json';
+ $EMONCMS_API_KEY='????VOTRE API KEY?????';

Création d’un utilisateur dédié avec pouvoir restreint

adduser --shell /bin/bash pvmonit

Installation des dépendances :

aptitude install lynx

On ajoute ensuite la possibilité à l’utilisateur exécutant l’export de lancer les scripts avec sudo sans mot de passe :

Lancer la commande :

visudo

Ajouter la ligne suivante :

+ pvmonit ALL=(ALL) NOPASSWD: /opt/temperv14/temperv14 -c, /usr/bin/perl /opt/PvMonit/bin/ampermetre.pl, /usr/bin/python /opt/PvMonit/bin/vedirect.py /dev/tty*

Test de collecte :

$ su - pvmonit -c /opt/PvMonit/getForEmoncms.php
2016-11-02T10:55:30+01:00 - C'est un MPTT, modèle "BlueSolar MPPT 100/30 rev2" du nom de MpttBleu
2016-11-02T10:55:30+01:00 - Les données sont formatées comme ceci : V:26180,I:800,VPV:56360,PPV:21,CS:3,ERR:0,H19:3352,H20:5,H21:51,H22:33,H23:167
2016-11-02T10:55:31+01:00 - C'est un MPTT, modèle "BlueSolar MPPT 100/30 rev2" du nom de MpttBlanc
2016-11-02T10:55:31+01:00 - Les données sont formatées comme ceci : V:26200,I:600,VPV:53630,PPV:18,CS:3,ERR:0,H19:1267,H20:4,H21:46,H22:17,H23:201
2016-11-02T10:55:31+01:00 - Après correction, la température est de 11.88°C
2016-11-02T10:55:31+01:00 - Tentative 1 de récupération de consommation
2016-11-02T10:55:32+01:00 - Trouvé à la tentative 1 : la La consommation trouvé est 00.1A
2016-11-02T10:55:32+01:00 - La consommation est de 00.1A soit 23W

Test d’envoi des données :

$ su - pvmonit -c /opt/PvMonit/sendToEmoncms.php 
2016-11-02T10:56:44+01:00 - Données correctements envoyées : 1, données en erreurs : 0

Mettre les scripts en tâche planifiée

crontab -e -u pvmonit

Ajouter :

+# Script de récupération des données, toutes les 5 minutes
+/5 * * * * /usr/bin/php /opt/PvMonit/getForEmoncms.php >> /tmp/PvMonit.getForEmoncms.log
+# Script d'envoi des données, ici toutes les 1/2 heures
+3,33 * * * * /usr/bin/php /opt/PvMonit/sendToEmoncms.php >> /tmp/PvMonit.sendToEmoncms.log

Je n’explique pas ici comment configurer emoncms, les flux pour obtenir de beaux dashboard, je vous laisse lire la documentation

Voici, pour exemple, mon dashboard : http://emoncms.mercereau.info/dashboard/view?id=1

Sonde température (option)

J’utilise la sonde thermomètre USB TEMPer, cette sonde fonctionne avec le logiciel temperv14 qui est plutôt simple à installer

apt-get install libusb-dev libusb-1.0-0-dev unzip
cd /opt
wget http://dev-random.net/wp-content/uploads/2013/08/temperv14.zip
#ou un miroir
#wget http://www.generation-linux.fr/public/juin14/temperv14.zip
unzip temperv14.zip
cd temperv14/
make

Test de la sonde :

$ /opt/temperv14/temperv14 -c
18.50

Ajout de celle-ci dans le fichier /opt/PvMonit/config.php :

- $TEMPERV14_BIN='';
+ $TEMPERV14_BIN='/usr/bin/sudo /opt/temperv14/temperv14';

Autres documentations à propos de cette sonde :

Pince ampèremétrique (option)

J’utilise la pince ampèremétrique USB Aviosys 8870 pour mesurer ma consommation électrique.

Le petit script perl (/opt/PvMonit/bin/ampermetre.pl) est très simple pour lire la pince ampèremétrique, qui sera branchée en USB et apparaîtra dans votre système sur le port /dev/ttyACM0

Celui-ci dépend de la librairie serialport :

aptitde install libdevice-serialport-perl

Test : :

$ /opt/PvMonit/bin/ampermetre.pl 
00.1A

Ajout de celle-ci dans le fichier /opt/PvMonit/config.php :

- $AMPEREMETRE_BIN = '';
+ $AMPEREMETRE_BIN = '/usr/bin/sudo /usr/bin/perl /opt/PvMonit/bin/ampermetre.pl';
Documentation

Voilà voilà, bon courage !

RaspberryPi & Raspbian en lecture seul (ReadOnly) pour préserver la carte SD

Le Raspberry Pi, est un mini ordinateur qui consomme très peu d’énergie. Il n’y a pas de disque dur mécanique, le système se trouve sur une carte SD.  L’avantage c’est que ça consomme moins d’énergie mais la carte SD à l’inconvénient de s’abîmer très rapidement quand il y a beaucoup de lecture/écriture (et sa durée de vie n’en ai que moindre). J’ai donc passé mon Raspberry Pi sous Raspbian (une Debian pré-packagé pour Raspberry) et mis en place un système en lecture seul. Il s’agit ici d’une installation type serveur sans interface graphique.

Installation de Raspbian (sans écran sur le Raspberry) avec connexion Wifi

Vue que je n’ai pas d’écran pour installer mon Raspberry, j’ai mis la carte SD dans mon ordinateur portable pour l’installation. Après le téléchargement de « Raspbien lite » sur le site officiel : http://www.raspbian.org. Il suffit d’utiliser la commande dd pour installer l’image :

david@portabuntu:~/Téléchargements$ unip raspbian_lite_latest.zip
david@portabuntu:~/Téléchargements$ sudo dd bs=4M if=2016-05-10-raspbian-jessie-lite.img of=/dev/sdc
330+1 enregistrements lus
330+1 enregistrements écrits
1386217472 octets (1,4 GB) copiés, 86,4596 s, 16,0 MB/s

Attention : remplacer /dev/sdc par le périphérique de votre carte SD ! (/dev/sdb, /dev/mmcblk0… un « sudo fdisk  -l » pourra vous en dire plus)

Éjecter la carte SD et remettez là, vous devriez avoir plusieurs partition sur la carte SD :

  • #1 : FAT32 (partition de boot)
  • #2 : ext3 (système)

Utilisation de gparted pour agrandir l’espace disque de la partition système :

Attention : cet article est vieux, préféré celui-ci pour la partie wifi : https://www.inpact-hardware.com/article/270/100830-comment-installer-simplement-raspberry-pi-sous-raspbian-avec-ssh-et-wi-fi-sans-ecran

On va maintenant préparer la connexion Wifi pour pouvoir l’attaquer en SSH :

sudo mkdir /mnt/sd-sys
sudo mount /dev/sdc2 /mnt/sd-sys # (la partition ext3)
sudo vi /mnt/sd-sys/etc/network/interfaces

L’édition de se fichier interface qui gère les cartes réseaux :

< iface wlan0 inet manual
< wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
---
> auto wlan0
> iface wlan0 inet static
> address 192.168.1.2
> netmask 255.255.255.0
> gateway 192.168.1.1
> wpa-ssid "VOTRE SSID WIFI"
> wpa-psk "VOTRE CLEF WAP PSK"

On spécifie le serveur DNS en modifiant le fichier /mnt/sd-sys/etc/network/interfaces

< #name_servers=127.0.0.1
---
> name_servers=192.168.1.1

Bien sûr il faut mette des IP’s de votre réseau…

On éjecte la carte :

david@portabuntu:~$ sudo umount /dev/sdc2 
david@portabuntu:~$ sudo eject /dev/sdc

On met la carte SD dans le Raspberry et on l’allume, on partiente que la connexion au Wifi soit faite et on test la connexion ssh :

david@portabuntu:~$ ssh pi@192.168.1.2 
The authenticity of host '192.168.1.2 (192.168.1.2)' can't be established.
ECDSA key fingerprint is fe:ed:f6:fe:e5:ea:28:bb:ad:6d:0c:2e:8f:b1:2c:5b.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.1.2' (ECDSA) to the list of known hosts.
pi@192.168.1.2's password: 

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
pi@raspberrypi:~ $ 

ça fonctionne !!!!

Passage du système en ReadOnly

Je me suis bien aidé des différents sites suivant :

Le reste des commandes va s’effectuer avec les droits root :

pi@raspberrypi:~ $ sudo -i
root@raspberrypi:~#

Il va falloir minimiser les programmes qui écrivent sur le FileSystème. On commence par désactiver la SWAP :

dphys-swapfile swapoff
dphys-swapfile uninstall
update-rc.d dphys-swapfile disable

Et on fait du ménage :

apt-get remove --purge logrotate dbus dphys-swapfile  fake-hwclock

Sauf si vous utilisez le DHCP, dans ce cas il faudra ajouter des choses pour que ça fonctionne en RO (« ln -s /tmp /var/lib/dhcp » par exemple…) sinon on supprime aussi le client DHCP :

aptitude purge isc-dhcp-client  dhcpcd5  isc-dhcp-common

On met l’horloge sur le bon fuseau horaire (Europe/Paris pour moi) :

rm /etc/localtime
ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime 

On remplace le « log manager » rsyslogd par busybox one qui fonctionne en RAM et on en FS :

apt-get install busybox-syslogd; dpkg --purge rsyslog

Pour lire les logs il faut utiliser la commande logread (logread -f correspond à un tail -f sur le syslog)

Encore un peu de ménage au démarrage :

systemctl disable bootlogs
systemctl disable sudo # Si vous n'utilisez pas sudo
systemctl disable alsa-utils # Si vous n'utilisez pas le son
systemctl disable console-setup
systemctl disable fake-hwclock # Certainement déjà absent à ce stade

A ce stade je conseil d’installer les petits outils indispensables

On désactive le bash_history soit en supprimant complètement le fichier

history -c
rm ~/.bash_history -rf
export HISTFILESIZE=0
unset HISTFILE
echo "HISTFILESIZE=0" >> ~/.bashrc

Soit en le déplaçant dans /tmp. Il sera remis à 0 à chaque reboot mais fonctionnera en read only.

+ HISTFILE="/tmp/${USER}_bash_history"

Avant de mettre le système en read only on va faire deux alias pour switcher du mode read-only on mode read-write facilement. Ajouter dans bashrc commun : /etc/bash.bashrc :

# Fonction pour connaître le mode en cours
fs_mode=$(mount | sed -n -e "s/^.* on \/ .*(\(r[w|o]\).*/\1/p")
# alias ro/rw pour passer de l'un à l'autre
alias ro='mount -o remount,ro / ; fs_mode=$(mount | sed -n -e "s/^.* on \/ .*(\(r[w|o]\).*/\1/p")'
alias rw='mount -o remount,rw / ; fs_mode=$(mount | sed -n -e "s/^.* on \/ .*(\(r[w|o]\).*/\1/p")'
# Modification du prompt pour afficher le mode en cours
export PS1='\[\033[01;32m\]\u@\h${fs_mode:+($fs_mode)}\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '

Aller hop, on passe au chose sérieuse, on modifie le /etc/fstab :

< /dev/mmcblk0p1  /boot           vfat    defaults          0       2
< /dev/mmcblk0p2  /               ext4    defaults,noatime  0       1
---
> /dev/mmcblk0p1  /boot           vfat    defaults,ro          0       2
> /dev/mmcblk0p2  /               ext4    defaults,noatime,ro  0       1
> tmpfs	/var/log	tmpfs	nodev,nosuid	0	0
> tmpfs	/var/tmp	tmpfs	nodev,nosuid	0	0
> tmpfs	/tmp	tmpfs	nodev,nosuid	0	0

Puis le fichier /boot/cmdline.txt :

< dwc_otg.lpm_enable=0 console=serial0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait
---
> dwc_otg.lpm_enable=0 console=serial0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait noswap ro

Après un reboot on peut tester :

root@raspberrypi(ro):~# touch /root/testEcriture
touch: cannot touch ‘/root/testEcriture’: Read-only file system
root@raspberrypi(ro):~# rw
root@raspberrypi(rw):~# touch /root/testEcriture
root@raspberrypi(rw):~# rm /root/testEcriture
root@raspberrypi(rw):~# ro
root@raspberrypi(ro):~#

ça fonctionne !

Le petit plus du chef, un petit script ~/.bash_logout pour ne pas oublier de remettre le FS en read only après avoir travaillé dessus…

#!/bin/bash
if [ "$fs_mode" != "ro" ]; then
	read -p "Le FS est en lecture/écriture, ne voudriez vous pas le basculer en lecture seul ? [O/n] " 
	if [[ ! $REPLY =~ ^[Nn]$ ]]
	then
		echo "Bascule en Read/Only"
		ro
	else
		echo "Ok on fait rien tant pi... Mais n'oublie pas que ça use la carte SD :-/"
	fi
fi

[API OVH] Reboot d’un VPS via un script PHP

OVH possède une API qui peut s’avérer très pratique pour automatiser des tâches du manager : https://api.ovh.com

J’ai choisi d’utiliser le PHP pour ces scripts car il est déjà installé sur mes machines, je n’ai donc pas besoin de supplément.

Premier test, lister mes VPS

Je commence gentils, je fais un script qui listera simplement les VPS disponible chez OVH.

Télécharger et décompressé la dernière version de « php-ovh » et ces dépendances : https://github.com/ovh/php-ovh/releases

root@monsrv:~# mkdir ovhphp/
root@monsrv:~# cd ovhphp/
root@monsrv:~/ovhphp# wget https://github.com/ovh/php-ovh/releases/download/v2.0.0/php-ovh-2.0.0-with-dependencies.tar.gz
root@monsrv:~/ovhphp# tar -xzvf php-ovh-2.0.0-with-dependencies.tar.gz 

Ensuite on crée un tocken via cette URL : https://api.ovh.com/createToken/?GET=/vps ou on ne va autoriser que le GET sur /vps.

On va obtenir la page suivante, il va falloir conserver Application Key, Application Secret & Consumer Key pour les mettre dans le script :

OVH api keys résulstatOn va pouvoir créer le script suivant (pensez à recopier vos Application Key, Application Secret & Consumer Key dans les variables) :

#!/usr/bin/php
<?php

// This script is a skeleton of script or application using OVH APIs
// You can launch it with the command php script.php
// Or include it into a website be deleting the first line

require __DIR__ . '/vendor/autoload.php';
use \Ovh\Api;

////////////////////////////////////////////////////
//     Dont forget to update your credentials     //
////////////////////////////////////////////////////

// Please read the documentation to get your credentials
// https://github.com/ovh/php-ovh
$applicationKey = "hsNT*************";
$applicationSecret = "8FcOC***********************";
$consumer_key = "bU5j**************************";

// Information about API and rights asked
$endpoint = 'ovh-eu';

// Get API connector instance
$conn = new Api(    $applicationKey,
                    $applicationSecret,
                    $endpoint,
                    $consumer_key);

////////////////////////////////////////////////////
//       Your logic will be inserted here         //
////////////////////////////////////////////////////

// This is an example
// Here, use the API connector as you want. Here, we are getting all hosting services
$vps = $conn->get('/vps');

print_r($vps);

?>

Lancement du script, voici le résultat :

root@romeo:~/ovhphp# php getvps.php 
Array
(
    [0] => vks00000.ip-XX-XX-XX.eu
)

vks00000.ip-XX-XX-XX.eu c’est le nom de mon VPS (pour l’exemple), ça fonctionne.

Les choses sérieuses :  un reboot

Même script avec action cette fois, pour tester le reboot d’un VPS via un script.

De nouveau la création d’API  avec l’url https://api.ovh.com/createToken/?POST=/vps/vks00000.ip-XX-XX-XX.eu/reboot. Ici on va autoriser le POST sur /vps/vks00000.ip-XX-XX-XX.eu/reboot.

#!/usr/bin/php
<?php
require __DIR__ . '/vendor/autoload.php';
use \Ovh\Api;
$applicationKey = "fCj********";
$applicationSecret = "vqm**************";
$consumer_key = "Zja************************";
$endpoint = 'ovh-eu';
$conn = new Api(    $applicationKey,
                    $applicationSecret,
                    $endpoint,
                    $consumer_key);
$vps_reboot = $conn->post('/vps/vks00000.ip-XX-XX-XX.eu/reboot');
print_r($vps_reboot);
?>

Au lancement on obtient le numéro de la tâche :

root@romeo:~# php postrebootvps.php
Array
(
    [progress] => 0
    [id] => 5119979
    [type] => rebootVm
    [state] => todo
)

Et ça fait bien redémarrer le VPS…

La finalité

De temps en temps mon VPS est inaccessible. C’est très variable (1 à 2 fois par mois environ) et je ne trouve pas la cause (OVH / système  / attaque ?). La seul solution pour le faire repartir c’est un reboot via le manager OVH. En attendant de trouver la cause (je ne désespère pas) j’ai mis en place ce script sur un serveur tiers afin de déclencher un reboot si le serveur est inaccessible.

#!/usr/bin/php
<?php

// Version 0.1 15/03/2015
// Reboot d'un VPS OVH (via l'API OVH) si celui-ci ne répond pas
// Par David Mercereau : http://david.mercereau.info
// Script sous licence BEERWARE

require __DIR__ . '/vendor/autoload.php';
use \Ovh\Api;
    
// Identifiant API OVH : https://api.ovh.com/createToken/
$applicationKey = "fCj********";
$applicationSecret = "vqm*************";
$consumer_key = "Zja***********************";
$endpoint = 'ovh-eu';
// Host à monitorer (IP du VPS)
$serveurMonitorIp = 'A.B.C.D';
// Port à monitorer (doivent être ouvert sur le VPS)
$serveurMonitorPorts = array(80, 22, 25);;
// Site qui permettent de vérifier la connexion internet
$hostsCheck = array('www.wordpress.com', 'fr.wikipedia.org', 'www.ovh.com');

function checkInternet($hostsCheck) {
    $return = true;
    foreach ($hostsCheck as $hostCheck) {
        if (!$sock = @fsockopen($hostCheck, 80, $num, $error, 5)) {
            echo "CheckInternet : Le serveur $hostCheck ne répond pas sur le port 80. Il n'y a pas internet ?\n";
            $return = false;
        }
    }
    return $return;
}

function serveurMonitor($serveurMonitorIp, $serveurMonitorPorts) {
    $return = true;
    foreach ($serveurMonitorPorts as $serveurMonitorPort) {
        if (!$sock = @fsockopen($serveurMonitorIp, $serveurMonitorPort, $num, $error, 5)) {
            echo "ServeurMonitor: Le serveur $serveurMonitorIp ne répond pas sur le port $serveurMonitorPort, Il n'est H.S. ?\n";
            $return = false;
        }
    }
    return $return;
}

if (! serveurMonitor($serveurMonitorIp, $serveurMonitorPorts)) {
    echo "...second test dans 2 minutes, c'est peut être temporaire...\n";
    sleep(120);
    if (! serveurMonitor($serveurMonitorIp, $serveurMonitorPorts)) {
        if  (checkInternet($hostsCheck)) {
            echo "Reboot de $serveurMonitorIp\n";
            // Conneixion à l'API
            $conn = new Api(    $applicationKey,
                                $applicationSecret,
                                $endpoint,
                                $consumer_key);
            $vps_reboot = $conn->post('/vps/vks10057.ip-37-59-126.eu/reboot');
            print_r($vps_reboot);
        } else {
            echo "Le serveur est peut être planté mais peut être pas... il ne semble pas y a voir interne, on fait rien !\n";
        }
    }
} 
exit(0);
?>

En tâche planifiée :

15,45 * * * *  /root/ovhphp/check-serveur.php