Ma Raspberry Pi MusicBox

On m’a récemment demandé de trouver une façon de faire jouer une liste Spotify en continu.

Au début, on me proposait d’utiliser une tablette, mais on voulait quelque chose qui pouvait être automatisé et configuré avec plus de flexibilité. Après quelques recherches, je suis tombé sur le projet Pi MusicBox qui répondait à mes besoins. Après quelques essais et erreurs, j’ai réussi à me faire une configuration plutôt stable. Un problème que j’ai eu à de multiples reprises, fut la corruption de la carte mircoSD (due à une interruption impromptue du Raspberry Pi), ce qui m’obligeait à recharger mon image et refaire toutes les configurations. J’ai fini par mettre mon Raspberry Pi en mode lecture seule, afin d’éviter que ce problème revienne.

Voici une procédure étape par étape de ma configuration.

Note : Pour pouvoir utiliser Spotify, vous devez disposer d’un compte premium.

Matériel utilisé :

Étape 1 configuration de la carte microSD

Puisque j’étais sous Windows, j’ai utilisé l’utilitaire Win32 Disk Imager. Il suffit de télécharger l’image de Pi MusicBox, disponible sur la page référée ci-dessus ou directement, en suivant ce lien https://github.com/pimusicbox/pimusicbox/releases/tag/v0.7.0RC6.

Sous Linux, vous pouvez utiliser l’utilitaire dd pour écrire l’image sur la carte microSD.

dd bs=4M if=musicbox_v0.7.0RC5.img of=/dev/sdX conv=fsync

/dev/sdX correspond au chemin vers votre carte microSD, en prenant pour acquis que vous êtes dans le répertoire où se trouve le fichier image.

Étape 2 connexion de la Raspberry Pi

Il est assez simple de brancher la Raspberry Pi, il suffit de brancher le fil réseau à la Pi, d’y connecter la prise analogue à votre amplificateur en utilisant le fil Jack à RCA, et d’y brancher le courant.

Il peut être pratique d’y connecter un écran et un clavier, mais ce n’était pas nécessaire (dans mon cas).

Étape 3 configuration (de base)

Vous devez d’abord identifier l’adresse IP de votre Pi. Personnellement, j’ai regardé l’attribution faite par mon serveur DHCP faite à ma Pi. Elle est facilement identifiable, son nom est MusicBox. Si vous avez branché un moniteur à la Pi, l’adresse IP devrait être affichée à l’écran.

Disons que l’adresse identifiée est : 192.168.0.10

Dans un fureteur, entrez l’adresse http://192.168.0.10 dans la barre d’adresse.

Vous devriez tomber sur l’interface web de la MusicBox.

  1. Dans la section Settings, nous allons d’abord configurer un mot de passe pour l’utilisateur root.
      1. Ouvrir l’onglet MusicBox.
      2. Mettre un mot de passe.
      3. Enregistrer les modifications.
      4. Appliquer les modifications et redémarrer le Pi.
    1. Effectuer les autres configurations possible via l’interface web (note : vos configurations peuvent varier). Retournez sur la Settings de l’interface web, puis :
      1. Dans l’onglet Network, activer la connexion SSH.
      2. Dans l’onglet MusicBox :
        1. Configurer l’URL de lecteur automatique (dans mon cas, pour Spotfiy) : spotify:user:Nom-d’utilisateur:playlist:Id-de-la-liste.
        2. Mettre le Autoplay Timeout à 600 secondes.
        3. Activer le Stream Watchdog.
      3. Dans l’onglet Audio, choisir la sortie Analog.
    2. Dans l’onglet Spotify :
      1. Activer l’option Enable playing music form Spotify.
      2. Entrer le nom d’utilisateur et le mot de passe de votre compte Spotify.
      3. Activer l’option Spotify Connect.
      4. Activer l’option Spotify Web.
      5. Suivre le lien https://www.mopidy.com/authenticate
      6. Copier le Client ID et le Client Secret dans les cases à cet effet.
    3. Enregistrer les modifications.
    4. Appliquer les modifications et redémarrer le Pi.

Si tout s’est bien passé, la musique de votre liste Spotify devrait jouer au redémarrage de la Pi.

Étape 4 configuration (avancée)

Vous devez d’abord vous connecter à la Pi, si vous y avez branché un moniteur et un clavier, il est possible de faire les configurations suivante directement sur la Pi, personnellement, je préfaire utiliser SSH pour faire ceci. Vous pouvez donc vous connecter à votre Pi en utilisant Putty (sous Windows) ou SSH (sous Linux).

Sous  Linux, utilisez la ligne de commande suivante pour vous connecter à votre Pi.

ssh -l root 192.168.0.10
  1. Configurer le fuseau horaire.
    dpkg-reconfigure tzdata
  2. Puisque je voulais que la liste Spotify joue de façon aléatoire et en boucle, j’ai aussi ajouter les lignes suivantes au fichier /opt/musicbox/startup.sh
    nano /opt/musicbox/startup.sh
    # trouver la ligne mpc add "$INI__musicbox__autoplay" et ajouter les deux lignes suivantes sous cette ligne.
                mpc random on
                mpc repeat on
    

Voilà! Tout est configuré. Mais, nous avions dit que nous voulions que la Pi soit en lecture seule, afin d’éviter la corruption de la carte microSD.

Étape 5 configuration de la Pi en lecture seule

Afin de me guider dans la configuration de ma Pi en lecture seule, je me suis basé sur les deux pages suivantes :

Le deuxième réfère à une installation Raspbian de base (utilisant Jessie), puisque nous utilisons Pi MusicBox (Wheezy), il faut en prendre et en laisser, voici ce que j’ai fait.

Désactivation de la swap et de la vérification du système de fichiers.

Il faut pour ce faire ajouter les paramètres fastboot noswap ro à la ligne de commande du fichier /boot/cmdline.txt.

Mon fichier original était comme ceci :

#                                             dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
dwc_otg.fiq_enable=1 dwc_otg.fiq_fsm_enable=1 dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Mon fichier modifié est donc comme ceci :

#                                             dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
dwc_otg.fiq_enable=1 dwc_otg.fiq_fsm_enable=1 dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait fastboot noswap ro

Déplacement de fichiers dans le système de fichier temporaire.

rm -rf /var/lib/dhcp/ /var/lib/dhcpcd5 /var/run /var/spool /var/lock
ln -s /tmp /var/lib/dhcp
ln -s /tmp /var/lib/dhcpcd5
ln -s /tmp /var/run
ln -s /tmp /var/spool
ln -s /tmp /var/lock

Installation du paquet resolvconf.

Afin de permettre la mise à jour des serveurs de noms par l’entremise de DHCP, nous devons installer le paquet resolvconf.

apt-get install resolvconf

Modification de la synchronisation de l’horloge internet.

Premièrement, installons le service ntp (Network Time Protocol).

apt-get install ntp

Puis, il faut modifier le fichier de configuration du service ntp pour permettre l’écriture (temporairement) lorsque l’heure est mise à jour. Pour ce faire, nous devons ajouter des lignes au fichier /etc/cron.hourly/fakehwclock.

Mon fichier original était comme ceci :

#!/bin/sh
#
# Simple cron script - save the current clock periodically in case of
# a power failure or other crash
 
if (command -v fake-hwclock >/dev/null 2>&1) ; then
  fake-hwclock save
fi

Mon fichier modifié est comme ceci :

#!/bin/sh
#
# Simple cron script - save the current clock periodically in case of
# a power failure or other crash
 
if (command -v fake-hwclock >/dev/null 2>&1) ; then
  mount -o remount,rw /
  fake-hwclock save
  mount -o remount,ro /
fi

Noter les modifications aux lignes 7 et 9 du fichier modifié.

Ensuite, nous devons rediriger le driftfile du fichier /etc/ntp.conf vers une zone inscriptible.

Mon fichier original contenait la ligne suivante :

driftfile /var/lib/ntp/ntp.drift

que j’ai commentée, puis j’ai ajouté une ligne comme ceci :

#driftfile /var/lib/ntp/ntp.drift
driftfile /var/tmp/ntp.drift

Modification de l’emplacement des logs de mopidy.

Afin de permettre l’écriture du fichier log de Mopidy, nous devons modifier l’emplacement du fichier en question. Pour ce faire, nous enlevons simplement le sous-répertoire mopidy du chemin du fichier de journalisation dans le fichier de configuration /etc/mopidy/logging.conf.

Mon fichier original était comme ceci :

[loggers]
keys = root

[handlers]
keys = fileHandler

[formatters]
keys = simpleFormatter

[logger_root]
#level = INFO
level = WARNING
handlers = fileHandler

[handler_fileHandler]
class = FileHandler

#level = INFO
level = WARNING
formatter = simpleFormatter
args = ('/var/log/mopidy/mopidy.log',)

[formatter_simpleFormatter]
format = %(asctime)s - %(levelname)-8s %(message)s
datefmt =

Mon fichier modifié est comme ceci :

[loggers]
keys = root

[handlers]
keys = fileHandler

[formatters]
keys = simpleFormatter

[logger_root]
#level = INFO
level = WARNING
handlers = fileHandler

[handler_fileHandler]
class = FileHandler

#level = INFO
level = WARNING
formatter = simpleFormatter
args = ('/var/log/mopidy.log',)

[formatter_simpleFormatter]
format = %(asctime)s - %(levelname)-8s %(message)s
datefmt =

Noter la modification de la ligne 21 de mon fichier.

Altération du démarrage

Tout d’abord, nous enlevons 2 scripts de démarrage en utilisant la ligne de commande suivante :

 insserv -r bootlogs; insserv -r console-setup

Finalement, nous modifions le fichier /etc/fstab afin de lui indiquer de monter les partitions en lecture seule.

Mon fichier original était comme ceci :

proc            /proc           proc    defaults          0       0
/dev/mmcblk0p1  /boot           vfat    defaults,user,rw,umask=000          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1
# a swapfile is not a swap partition, so no using swapon|off from here on, use  dphys-swapfile swap[on|off]  for that
/dev/mmcblk0p3  none            swap    sw                0       0

Mon fichier modifié est comme ceci :

proc            /proc           proc    defaults          0       0
/dev/mmcblk0p1  /boot           vfat    defaults,user,umask=000,ro          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime,ro  0       1
# a swapfile is not a swap partition, so no using swapon|off from here on, use  dphys-swapfile swap[on|off]  for that
#/dev/mmcblk0p3  none            swap    sw                0       0

# Tmpfs
tmpfs          /tmp             tmpfs   nosuid,nodev      0       0
tmpfs          /var/log         tmpfs   nosuid,nodev      0       0
tmpfs          /var/log         tmpfs   nosuid,nodev      0       0

Noter les modifications  aux lignes 2 et 3 (ajout du paramètre ro pour readonly) ainsi qu’à la ligne 5 que j’ai commentée. Je ne suis pas certain que la modification de la ligne 5 était nécessaire, mais tout semble bien tourner avec cette configuration.

Redémarrer

Nous avons terminé, il ne reste qu’à redémarrer la Raspberry Pi afin d’appliquer toutes les modifications.

Comment passer du mode lecture seule au mode lecture/écriture

Si vous devez passer en mode lecture/écriture afin de modifier une configuration ou pour toute autre raison. Vous pouvez utiliser la ligne de commande suivante :

mount -o remount,rw /

Pour retourner en mode lecture seule, utilisez la commande suivante :

mount -o remount,ro /

Voilà!

Tout est configuré, vous pouvez maintenant profiter de votre MusicBox.

Traduction des fonctions Excel en français

Voici une référence de fonctions Excel traduites en français.

 

Lire la suite

ANGLAIS FRANÇAIS
ABS ABS
ABSREF REFABS
ACOS ACOS
ACOSH ACOSH
ACTIVE.CELL CELLULE.ACTIVE
ADD.BAR AJOUTER.BARRE
ADD.COMMAND AJOUTER.COMMANDE
ADD.MENU AJOUTER.MENU
ADD.TOOLBAR AJOUTER.BARRE.OUTILS
ADDRESS ADRESSE
AND ET
APP.TITLE APP.TITRE
AREAS ZONES
ARGUMENT ARGUMENT
ASC ASC
ASIN ASIN
ASINH ASINH
ATAN ATAN
ATAN2 ATAN2
ATANH ATANH
AVEDEV ECART.MOYEN
AVERAGE MOYENNE
BETADIST LOI.BETA

Comment supprimer une règle précise de iptables.

Il peut parfois être nécessaire de supprimer une règle de la liste de iptables. La commande pour ce faire est assez simple. Au moins deux options s’offrent à nous.

  1. Supprimer la règle en utilisant tous ses paramètres.
sudo iptables -D <chaine> [-s <adresse IP>] [-d <adresse IP>] [-p <protocole>] [--dport <port>] -j <action>

Par exemple :

sudo iptables -D INPUT -s 1.1.1.1 -p tcp --dport 123 -j ACCEPT
  1. Supprimer la règle en utilisant son numéro de ligne.
sudo iptables -D <chaine> <numéro de ligne>

Par exemple :

sudo iptables -D INPUT 3

D’accord, c’est bien beau tout ça, mais si nous avons des centaines de règles dans notre pare-feu, comment en récupérer facilement le numéro de ligne? Dans mon cas, j’utilise fail2ban pour protéger mon serveur contre les attaques de type bruteforce sur le service SSH. Il en résulte donc que mon pare-feu contient un nombre impressionnant de règles. En fait récupéré le numéro de ligne peut-être bien plus simple qu’il n’y parait.

Par exemple, disons que je cherche à supprimer une adresse IP en particulier (ici, l’adresse 123.123.123.123) de mon pare-feu dans la chaîne fail2ban-ssh.

sudo iptables -L fail2ban-ssh -n --line-number | grep 123.123.123.123

Le résultat de cette commande (si l’adresse 123.123.123.123 est bel et bien bannie) serait similaire à ceci :

323  REJECT     all  --  123.123.123.123         0.0.0.0/0            reject-with icmp-port-unreachable

Où le contenu de la première colonne serait le numéro de ligne, dans cet exemple 323.

Il ne nous resterait qu’à supprimer la ligne 323 avec la commande suivante.

sudo iptables -D fail2ban-ssh 323

Voilà!

Comment exporter une liste des licences des utilisateurs d’Office 365.

Pour télécharger le référentiel GitHub, veuillez suivre ce lien.

Ce script PowerShell créera un fichier LogonTime.csv dans le répertoire actif.

#===============================================================
# author:	Julien Bonnier 
# file:		getMsolLicenses.ps1
# project:	office365licenses
# version:	1.0.2.20170425.1448
# url:		https://github.com/jbonnier/office365licenses
#===============================================================

$LiveCred = Get-Credential
$ExchangeSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell/ -Credential $LiveCred -Authentication Basic -AllowRedirection
Connect-MsolService -Credential $LiveCred
Import-PSSession $ExchangeSession
$mailboxes = Get-Mailbox -ResultSize Unlimited | Where {$_.RecipientTypeDetails -Ne "DiscoveryMailbox"} 
$arr = @()
foreach ($mailbox in $mailboxes) {
	$obj = New-Object -TypeName PSObject
	$stats = Get-MailboxStatistics -Identity $mailbox.Identity
	$msolUser = Get-MsolUser -UserPrincipalName $mailbox.UserPrincipalName
	$licenses = ""
	foreach ($license in $msolUser.Licenses) {
		if ($license.AccountSkuId -Like "*:VISIOCLIENT") { $licenses += "Visio, " }
		elseif ($license.AccountSkuId -Like "*:EXCHANGE*") { $licenses += "Exchange, " }
		elseif ($license.AccountSkuId -Like "*:POWER_BI_*") { $licenses += "Power-Bi, " }
		elseif ($license.AccountSkuId -Like "*:OFFICESUBSCRIPTION") { $licenses += "Office, " }
		else { $licenses += "$license.AccountSkuId, "}
	}
	if ($licenses.Length -Ne 0) { $licenses = $licenses.Substring(0, $licenses.Length-2) }
	Add-Member -InputObject $obj -MemberType NoteProperty -Name Identity -Value $mailbox.Identity
	Add-Member -InputObject $obj -MemberType NoteProperty -Name DisplayName -Value $mailbox.DisplayName
	Add-Member -InputObject $obj -MemberType NoteProperty -Name Address -Value $mailbox.PrimarySmtpAddress
	Add-Member -InputObject $obj -MemberType NoteProperty -Name Licensed -Value $msolUser.islicensed
	Add-Member -InputObject $obj -MemberType NoteProperty -Name "License(s)" -Value $licenses
	Add-Member -InputObject $obj -MemberType NoteProperty -Name LastLogonTime -Value $stats.LastLogonTime
	$arr += $obj
} $arr | Export-Csv LogonTime.csv
Remove-PSSession $ExchangeSession

Cloche programmable Raspberry Pi

Nous utilisions, au travail, un système de cloches complètement archaïque qui datait de Mathusalem (ou presque). La programmation de cette cloche était très complexe et aucune documentation n’était disponible. Puisque la programmation de la cloche avait été faite avant le changement de date des changements d’heures en Amérique du Nord (2007) et que personne ne semblait savoir comment programmer le changement d’heure de la cloche, je devais changer, 4 fois par année, l’heure du système. De plus, notre ancien système prenait du retard (environ 10 minutes par année). Alors, lorsqu’on m’a demandé s’il était possible d’ajouter une deuxième cloche à notre système, j’ai proposé de créer un nouveau système digne de notre siècle pour remplacer notre vieillerie.

Matériel requis :

  • 2 fils Dupont mâle/femelle (rouge)
  • 1 fil Dupont mâle/femelle (noir)
  • 2 fils Dupont mâle/mâle (rouge)
  • 6 fils Dupont mâle/mâle (noir)
  • 2 cloches Ajax Scientific Deluxe Electric Bell (ASIN: B00EPQKIXE)
  • 1 planche de montage expérimental (breadboard)
  • 1 puce à circuit intégré ULN2003A
  • 1 Raspberry Pi (B+ v1.2 dans mon cas)
  • 1 connecteur DC femelle 2.1 pour planche de montage expérimental
  • 1 adaptateur DC-16V 1A
  • 1 carte micro SD 4Go (ou plus)
  • 1 chargeur micro USB
  • 1 fil réseau

Matériel optionnel :

  • 1 cable HDMI
  • 1 écran compatible HDMI
  • 1 clavier USB

Étape 1 : préparer le Raspberry Pi.

Téléchargez et extraire Raspbian Jessie Lite sur un ordinateur pouvant lire les cartes SD (ou utiliser un adaptateur micro SD/USB), puis montez l’image sur la carte SD.

Sous Linux :

dd bs=4M if=/chemin/vers/2017-01-11-raspbian-jessie-lite.img of=/dev/sdX

En remplaçant /chemin/vers/ par l’emplacement où se trouve le fichier image et /dev/sdX par le périphérique correspondant à la carte micro SD.

Sous Windows :

Utilisez un programme tel que Win32 Disk Imager pour transférer l’image sur la carte micro SD.

Puis, insérez la carte micro SD dans le Raspberry Pi (RPi) et démarrer celui-ci. Connectez-vous sur le RPi en utilisant l’utilisateur pi et le mot de passe raspberry, puis lancer l’utilitaire raspi-config.

sudo raspi-config

Nous allons d’abord étendre le système de fichier en choisissant l’option 1. Ensuite, nous devons activer quelques options avancées notamment SPI, I2C et accessoirement SSH (afin de simplifier la gestion).

Nous pouvons maintenant choisir l’option Finish et redémarrer le RPi. Nous pouvons vérifier que les modules sont bel et bien installés à l’aide de la commande suivante.

lsmod | grep -E '(spi|i2c)'

Maintenant, nous allons mettre les paquets apt à jour, puis installer certains paquets nécessaires au fonctionnement de notre projet.

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install git build-essential libi2c-dev python-dev python3-pip python-pip libffi-dev i2c-tools python2.7-dev python3-dev libevent-dev
sudo pip install spidev
sudo pip install smbus-cffi

Voilà, le RPi est prêt pour l’utilisation des entêtes GPIO.

Étape 2 : création du fichier pi_bell.py.

Créons un nouveau fichier pi_bell.py dans le sous-répertoire pi_bell répertoire « home » de l’utilisateur pi ou clonons simplement mon référentiel GitLab. Il est conseillé de cloner le référentiel plutôt que de créer le fichier, puisque le référentiel sera possiblement mis à jour.

mkdir ~/pi_bell
nano ~/pi_bell/pi_bell.py

Puis, compions le contenu du fichier.

#!/usr/bin/python
# -*- coding: latin-1 -*-

__author__ = "Julien Bonnier <[email protected]>"
__copyright__ = "Copyright 2017, Julien Bonnier"
__license__ = "GPL"
__maintainer__ = "Julien Bonnier"
__email__ = "[email protected]"

__date__ = "$2017-02-21 13:53$"
__version__ = "0.0.0.20170221.1353"
__status__ = "Production"

# Import des modules
from datetime import datetime
from threading import Timer
import time
import sys
import atexit

try:
	import RPi.GPIO as GPIO
except ImportError as e:
	print "RPi GPIO module not installed."
	print "Application will abort."
	sys.exit()
except:
	print "Unexpected error:", sys.exc_info()[0]
	sys.exit()

# Declaration de variables
bell_pins = [11, 12]	#gpio 17, 18
ring_time = 3			#secondes

# Initialisation de la numerotation et des E/S
def setupGPIO():
	GPIO.setmode(GPIO.BOARD)
	for pin in bell_pins:
		GPIO.setup(pin, GPIO.OUT, initial = GPIO.LOW)

def init():
	setupGPIO()
	ring()

# On fait sonner la cloche.
def ring():
	for pin in bell_pins:
		GPIO.output(pin, GPIO.HIGH)
	time.sleep(ring_time)
	for pin in bell_pins:
		GPIO.output(pin, GPIO.LOW)

def quit():
	print "Exiting..."
	try:
		GPIO.cleanup()
		print "GPIO cleaned up!"
	except:
		print "Unexpected error:", sys.exc_info()[0]
		
if __name__ == '__main__': 
	init()

atexit.register(quit)

Ou, clonons simplement le référentiel GitLab comme suit :

git clone https://gitlab.com/j.bonnier/pi_bell.git

Consulter le référentiel GitLab.

Étape 3 : Brancher les composantes.

Avertissement : il est conseillé d’éteindre le RPi avant d’y connecter d’autres composantes. De plus, veuillez redoubler de prudence en jouant avec les courants électriques.

Cette étape est plutôt simple, nous n’avons qu’à connecter les composantes en conformité avec le schéma suivant.

Étape 4 : Tester le fonctionnement du système.

À cette étape, le système de cloches devrait être fonctionnel. Pour tester le bon fonctionnement de celui-ci, nous devons taper la commande suivante dans la console.

python ~/pi_bell/pi_bell.py

Si vous obtenez un message d’erreur comme celui-ci :

RuntimeError: No access to /dev/mem. Try running as root!

Vous essayez probablement d’exécuter la commande en tant qu’un utilisateur autre que pi. Par défaut, l’utilisateur pi a accès aux GPIO. Vous pouvez toutefois ajouter quelques groupes à votre utilisateur pour lui donner accès au contrôle des GPIO. Par exemple, pour autoriser l’utilisateur julien à contrôler les GPIO, j’entrerais la commande suivante.

sudo usermod -a -G gpio,i2c,spi julien

Étape 5 : Programmer la cloche.

La programmation de la cloche se fait à l’aide des crontabs.

Afin de ne pas effacer les crontabs que nous pourrions déjà avoir, nous en faisons une sauvegarde dans un fichier temporaire nommé cron.tmp  auquel nous allons ajouter quelques lignes. Dans cet exemple, nous allons programmer les cloches pour qu’elles sonnent à midi et à 16 h 30 tous les jours de semaine (du lundi au vendredi). Puis, nous allons mettre à jour les crontabs et finalement nous effaçons notre fichier temporaire.

crontab -l > cron.tmp
echo "00 12 * * 1-5 python /home/pi/pi_bell/pi_bell.py" >> cron.tmp
echo "30 16 * * 1-5 python /home/pi/pi_bell/pi_bell.py" >> cron.tmp
crontab cron.tmp
rm cron.tmp

Voilà!

Nous avons maintenant une cloche moderne qui sonnera quand et comme nous le voulons!

Mon script de message du jour perso pour Debian.

Consulter le référentiel GitLab.

#!/bin/bash

PROCCOUNT=`ps -Afl | wc -l`
PROCCOUNT=`expr $PROCCOUNT - 5`
GROUPZ=`groups`
USER=`whoami`
ADMINS=`cat /etc/group | grep --regex "^sudo" | awk -F: '{print $4}' | tr ',' '|'`
ADMINSLIST=`grep -E $ADMINS /etc/passwd | tr ':' ' ' | tr ',' ' ' | awk {'print $5,$6,"("$1")"'} | tr '\n' ',' | sed '$s/.$//'`

if [[ $GROUPZ == "$USER sudo" ]]; then
USERGROUP="Administrator"
elif [[ $USER = "root" ]]; then
USERGROUP="Root"
elif [[ $USER = "$USER" ]]; then
USERGROUP="Regular User"
else
USERGROUP="$GROUPZ"
fi
echo -e "
\033[1;31m                                      ╔═════════════════════════[\033[1;37mSystem Data\033[1;31m]═════════════════════════════════════
\033[1;31m                                      ║\033[1;37m       Hostname\033[1;31m: \033[1;37m`hostname`
\033[1;31m          _,met\$\$\$\$\$gg.               ║\033[1;37m   IPv4 Address\033[1;31m: \033[1;37m`ip addr show eth0 | grep "inet\ " | awk {'print $2'}`
\033[1;31m       ,g\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$P.            ║\033[1;37m   IPv6 Address\033[1;31m: \033[1;37m`ip addr show eth0 | grep -m 1 "inet6\ " | awk {'print $2'}`
\033[1;31m     ,g\$\$P\"\"       \"\"\"Y\$\$.\".          ║\033[1;37m         Kernel\033[1;31m: \033[1;37m`uname -r`
\033[1;31m    ,\$\$P'              \\`\$\$\$.          ║\033[1;37m         Distro\033[1;31m: \033[1;37m`cat /etc/*release | grep \"PRETTY_NAME\" | cut -d "=" -f 2- | sed 's/\"//g'`
\033[1;31m  ',\$\$P       ,ggs.     \\`\$\$b:         ║\033[1;37m         Uptime\033[1;31m: \033[1;37m`uptime | sed 's/.*up ([^,]*), .*/1/'`
\033[1;31m  \\`d\$\$'     ,\$P\"'   .    \$\$\$          ║\033[1;37m           Time\033[1;31m: \033[1;37m`date`
\033[1;31m   \$\$P      d\$'     ,    \$\$P          ║\033[1;37m            CPU\033[1;31m: \033[1;37m`cat /proc/cpuinfo | grep "model name" | cut -d ' ' -f3- | awk {'print $1,$2,$3,$4,$5,$6,$7,$8,$9,$10'} | head -1`
\033[1;31m   \$\$:      \$\$.   -    ,d\$\$'          ║\033[1;37m         Memory\033[1;31m: \033[1;37m`free -t -m | grep "Mem" | awk {'print $4'}`MB Available, `free -t -m | grep "Mem" | awk {'print $3'}`MB Used, `free -t -m | grep "Mem" | awk {'print $2'}`MB Total
\033[1;31m   \$\$;      Y\$b._   _,d\$P'            ║\033[1;37m      HDD Usage\033[1;31m: \033[1;37m`df -T $HOME | awk '{ SUM += $3} END { printf("%.2f\n", SUM/1024/1024) }'`GB Available, `df -T $HOME | awk '{ SUM += $4} END { printf("%.2f\n", SUM/1024/1024) }'`GB Used, `df -T $HOME | awk '{ SUM += $5} END { printf("%.2f\n", SUM/1024/1024) }'`GB Total
\033[1;31m   Y\$\$.    \\`.\\`\"Y\$\$\$\$P\"'               ╠═════════════════════════[\033[1;37mUser Data\033[1;31m]═══════════════════════════════════════
\033[1;31m   \\`\$\$b      \"-.__                    ║\033[1;37m       Username\033[1;31m: \033[1;37m`whoami`
\033[1;31m    \\`Y\$\$b                             ║\033[1;37m      Usergroup\033[1;31m: \033[1;37m$USERGROUP
\033[1;31m     \\`Y\$\$.                            ║\033[1;37m     Last Login\033[1;31m: \033[1;37m`last -a $USER | head -2 | awk 'NR==2{print $3,$4,$5,$6}'` from `last -a $USER | head -2 | awk 'NR==2{print $10}'`
\033[1;31m       \\`\$\$b.                          ║\033[1;37m       Sessions\033[1;31m: \033[1;37m`who | grep $USER | wc -l`
\033[1;31m         \\`Y\$\$b.                       ║\033[1;37m      Processes\033[1;31m: \033[1;37m$PROCCOUNT of `ulimit -u` max
\033[1;31m           \\`\"Y\$b._                    ║\033[1;37m        Screens\033[1;31m: \033[1;37m`screen -ls | sed ':a;N;$!ba;s/\\n/ /g'`
\033[1;31m               \\`\"\"\"\"                  ╠═════════════════════════[\033[1;37mHelpful info\033[1;31m]════════════════════════════════════
\033[1;31m                                      ║\033[1;37m Administrators\033[1;31m: \033[1;37m$ADMINSLIST
\033[1;31m                                      ╚═══════════════════════════════════════════════════════════════════════════\e[0m
"

Configuration de mon serveur web de développement PHP7 sous Debian 8

Voici la configuration de mon serveur web de développement PHP7, Apache2, MySQL, phpMyAdmin sous Debian 8 Jessie. Vu la difficulté à installer PHP7 et phpMyAdmin, j’ai cru bon de créer un tutoriel sur la configuration de mon environnement étape par étape.

Ceci se base sur le fait que ma machine était une machine Debian de base avec comme seul paquet supplémentaire sudo. Mon utilisateur étant membre du groupe sudo.

Étape 1 : Mettre à jour les sources du gestionnaire de paquets apt.

Nous ajoutons d’abord le référentiel Dotdeb qui fournit des paquets à jour pour PHP7 (entre autres), puisque celui-ci n’est pas offert (à ce jour) dans les référentiels officiels de Debian.

Note : Ce référentiel est également valide pour Debian 7 Wheezy, il faudrait toutefois changer le nom de la version dans les commandes suivantes.

sudo bash -c "echo 'deb http://packages.dotdeb.org jessie all' >> /etc/apt/sources.list"
sudo bash -c "echo 'deb-src http://packages.dotdeb.org jessie all' >> /etc/apt/sources.list"

Étape 2 : Installer la clef GnuPG pour le référentiel de Dotdeb.

wget https://www.dotdeb.org/dotdeb.gpg
sudo apt-key add dotdeb.gpg
rm dotdeb.gpg

Étape 3 : Mettre le gestionnaire de paquets apt à jour.

sudo apt-get update

Étape 4 : Installer les paquets nécessaires.

sudo apt-get install apache2 php7.0 php7.0-fpm php7.0-gd php7.0-mysql php7.0-mbstring mysql-server

Pendant l’installation de mysql-server, vous devriez avoir à entrer un mot de passe pour l’utilisateur d’administration; ce mot de passe sera nécessaire pour tester phpMyAdmin à l’étape 9.

Étape 5 : Configurer Apache pour l’utilisation de PHP7.

sudo a2enmod proxy_fcgi setenvif
sudo a2enconf php7.0-fpm

Puis, nous redémarrons le service web.

sudo service apache2 reload

Étape 6 : Tester l’installation d’Apache et de PHP7.

Nous créons d’abord un fichier test.php pour y afficher les informations relatives à php dans le DocumentRoot de notre serveur web. Par défaut, sous Debian 8 avec Apache2, le DocumentRoot devrait être /var/www/html/.

sudo bash -c "cat >> /var/www/html/test.php" << EOL
<?php
phpinfo();
?>
EOL

Nous devrions être capables de naviguer vers le serveur de développement sur la page test.php et obtenir quelque chose de similaire à ceci.


Étape 7 : Tester l’installation de MySQL server.

Pour tester l’installation de mysql-server, il suffit d’entrer une commande comme celle-ci :

mysql -u root -p -e "show databases"

Cette commande devrait afficher le nom des bases de données présentes sur votre serveur.

Étape 8 : Installer phpMyAdmin.

Dans ce tutoriel, j’installerai phpMyAdmin dans le répertoire /var/www/phpmyadmin et je créerai un VirtualHost pour ce répertoire.

L’archive de phpMyAdmin que nous utiliserons est au format zip, tapper la commande suivante pour installer l’utilitaire unzip si vous ne l’avez pas par défaut.

sudo apt-get install unzip

D’abord, téléchargeons l’archive de phpMyAdmin et installons-la dans le répertoire voulu.

sudo wget https://files.phpmyadmin.net/phpMyAdmin/4.5.3.1/phpMyAdmin-4.5.3.1-all-languages.zip -P /var/www/
sudo unzip /var/www/phpMyAdmin-4.5.3.1-all-languages.zip
sudo mv /var/www/phpMyAdmin-4.5.3.1-all-languages/ /var/www/phpmyadmin
sudo rm /var/www/phpMyAdmin-4.5.3.1-all-languages.zip

Puis, nous allons créer un fichier de configuration de phpMyAdmin en nous basant sur l’exemple fourni.

sudo cp /var/www/phpmyadmin/config.sample.inc.php /var/www/phpmyadmin/config.inc.php

Et nous y modifions une ligne pour ajouter une clef Blowfish secrète à la configuration de phpMyAdmin.

k=$(openssl rand -base64 32 | sed 's,\/,\\/,g')
o="\$cfg\['blowfish_secret'\] = '';"
n="\$cfg\['blowfish_secret'\] = '$k';"
sudo perl -p -i -e "s/$o/$n/g" /var/www/phpmyadmin/config.inc.php

Maintenant, vérifions que la clef a bel et bien été ajoutée.

cat /var/www/phpmyadmin/config.inc.php | grep blowfish

La sortie devrait être similaire à ceci (avec une clef différente).

$cfg['blowfish_secret'] = 'GdU9dq0/miodjA1DtIqqqZGvHEO/k2brFzpnOec5m2o='; /* YOU MUST FILL IN THIS FOR COOKIE AUTH! */

Finalement, nous créons un VirtualHost pour phpMyAdmin.

D’abord, nous créons un fichier de configuration pour le site phpMyAdmin.

sudo bash -c "cat >> /etc/apache2/sites-available/phpmyadmin.conf" << EOL
Alias /phpmyadmin /var/www/phpmyadmin

<Directory /var/www/phpmyadmin>
 Options FollowSymLinks
 DirectoryIndex index.php
</Directory>
EOL

Puis nous activons le site et nous redémarrons Apache2.

sudo a2ensite phpmyadmin.conf
sudo service apache2 restart

Étape 9 : Tester l’installation de phpMyAdmin.

Nous devrions être capables de naviguer vers le site phpMyAdmin de notre serveur de développement.

Il ne nous reste qu’à nous connecter à phpMyAdmin avec l’utilisateur root et le mot de passe choisi à l’étape 4.

Voilà!

Notre serveur web de développement est fonctionnel avec PHP7 et phpMyAdmin.

Comment régler les problèmes de connexions refusées sur ps.outlook.com.

Lorsque vous tentez de vous connecter à la console Exchange d’Office 365 en utilisant PowerShell et que vous recevez le message suivant :

New-PSSession : [ps.outlook.com] La connexion au serveur distant ps.outlook.com a échoué avec le message d’erreur suivant: […] Access Denied […].

Office 365 PowerShell Access Denied -2144108477

Assurez-vous d’abord que les informations de connexion sont valides. Si le problème persiste, il est possible que votre utilisateur n’ait pas l’autorisation pour gérer l’organisation; voici comment y remédier.

  1. Ouvrez le portail web d’administration d’Office 365.
    1. https://portal.office.com/
  2. Accédez à l’administration d’Exchange.
  3. Ouvrez l’onglet des autorisations.
  4. Modifier les autorisations pour Organisation Management.
  5. Ajouter l’adresse courriel utilisée pour vous connecter à Office 365 avec PowerShell dans la section Membres.
  6. Enregistrer les changements.

Voilà! Vous devriez pouvoir vous connecter à Office 365 en utilisant PowerShell.

Comment trouver les membres d’une liste de distribution Office 365.

Pour vous savoir comment vous connecter à la console Exchange d’Office 365, veuillez vous référer à cet article.
 
Pour lister les groupes de distribution :

Get-DistributionGroup

Pour lister les membres des groupes de distribution :

Get-DistributionGroup | ForEach-Object { Get-DistributionGroupMember -Identity $_.name }

Pour lister le nom des contacts faisant parti de groupes de distribution avec le nom de ce dernier :

Get-DistributionGroup | ForEach-Object { $name = $_.name; Get-DistributionGroupMember -Identity $_.name } | Where { $_.RecipientType -Eq "MailContact" } | ForEach-Object { Write-Host "$name`t$_.name" }

Comment se connecter à Office 365 Exchange avec PowerShell.

Voici comment vous pouvez vous connecter à Exchange Online en utilisant PowerShell.
Les étapes 2, 3 et 7 sont optionnelles.
 

  1. Ouvrir PowerShell, sur un ordinateur utilisant Windows.
    • En utilisant le menu démarrer.
      • Ouvrir le menu démarrer,
      • Accéder à Tous les programmes,
      • Ouvrir le dossier Accessoires,
      • Cliquer sur Windows PowerShell.
    • En utilisant l’utilitaire Exécuter
      • Appuyer sur Windows+R,
      • Tapper : PowerShell
  2. Dans la fenêtre PowerShell, vérifier que vous pouvez exécuter les scripts RemoteSigned.
    Get-ExecutionPolicy

    Si la valeur retournée est différente de « RemoteSigned », vous devez changer la valeur telle que décrite à l’étape 3, sinon, vous pouvez passer directement à l’étape 4.

  3. Pour activer les scripts RemoteSigned dans PowerShell, taper la commande suivante :
    Set-ExecutionPolicy RemoteSigned
  4. Connecter PowerShell au service infonuagique, taper les commandes suivantes.
    $LiveCred = Get-Credential
    
    # Note : En saisissant cette commande, une boîte de dialogue de connexion s’ouvrira. Vous devez entrer les informations de connexion d’un compte administrateur de votre <em>Office 365</em>.
    
    $Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell/ -Credential $LiveCred -Authentication Basic -AllowRedirection
    
    Import-PSSession $Session
  5. Effectuer les travaux que vous avez à faire sur la console d’Exchange Office 365.
  6. Fermer la connexion au service infonuagique.
    Remove-PSSession $Session
  7. Vous pouvez ensuite rétablir la valeur de Get-ExecutionPolicy modifiée à l’étape 3 par la valeur obtenue à l’étape 2 (optionnel).
    Set-ExecutionPolicy "Valeur obtenue à l’étape 2"

    Vous devrez remplacer « Valeur obtenue à l’étape 2 » par la valeur que vous avez obtenue précédemment. Les guillemets ne doivent pas être entrés dans cette commande, ils ne servent, ici, qu’à simplifier la lecture.

Voilà!