William's Blog » Script

Sauvegarde incrémentale avec rsync : fichiers et base de données MySQL

Will — Wed, 07 Jul 2010 12:24:14 +0000

Bonjour, suite à mon passage en dédié (Dédibox v3) et à sa configuration aujourd’hui terminée, j’ai trouvé nécessaire de m’occuper de la sauvegarde des données. Pour cela, je me suis aidé de plusieurs sources :

http://www.ruas-blog.com/index.php/2006/03/06/33-script-de-sauvegarde-des-bases-mysql (pour backuper MySQL)
http://www.casafire.com/fr/content/sauvegarde-incrémentale-de-fichiers-avec-rsync-et-ssh (pour backuper les fichiers)
http://blog.mazenod.fr/2007/10/sauvegarde-cryptee-de-serveur-a-serveur/ (pour me rappeler les commandes d’usage)

Sauvegarde des bases MySQL

Je sauvegarde toutes les bases de données sur une durée d’une semaine. Voici le script, il est possible de le coupler à un envoi de la sauvegarde via FTP. Je conserve ainsi toutes mes sauvegardes sur un serveur distant et complètement déconnecté de ce dont je vais vous parler ensuite.

#!/bin/bash

#---------------------------------------------------------------#
# Paramétrage de la connection MySQL #
#---------------------------------------------------------------#

#Nom de l'utilisateur qui lance le backup
user=<user>
#Machine sur laquelle on se connecte
host=<host>
#Mot de passe de l'utilisateur de backup
pass=<password>

# Outil de dump
MYSQLDUMP=mysqldump
#Outil de check
MYSQLCHECK=mysqlcheck
# Options passées à MYSQLDUMP
OPTIONS="--add-drop-database --add-drop-table --complete-insert --routines --triggers --max_allowed_packet=250M --force"

#---------------------------------------------------------------#
# Paramétrage de la sauvegarde #
#---------------------------------------------------------------#

# Répertoire temporaire pour stocker les backups
TEMPORAIRE="/tmp/bkp_mysql"

# Nom du serveur
MACHINE="$(hostname)"

# Date courante
DATE="$(date +"%d-%m-%Y")"
# Date de conservation maximum
DATE2=`date --date '1 week ago' "+%d-%m-%Y"`

# Nom des fichiers de backup
# Répertoire de destination du backup
DESTINATION="/home/backuper/mysql"
FICHIER_BACKUP=$MACHINE"_BACKUP_MYSQL_"$DATE".tar.gz"
FICHIER_EFFACER=$MACHINE"_BACKUP_MYSQL_"$DATE2".tar.gz"

#Informations FTP
LOGIN_FTP=<user_ftp>
PASS_FTP=<pass_ftp>
HOST_FTP=<host_ftp>

#---------------------------------------------------------------#
# Process de sauvegarde #
#---------------------------------------------------------------#

# Création du répertoire temporaire
if [ -d $TEMPORAIRE ];
then
echo "Le repertoire temporaire existe.";
else
mkdir $TEMPORAIRE;
fi

# On construit la liste des bases de données
BASES="$(mysql -u $user -h $host -p$pass -Bse 'show databases')"

# On lance le dump des bases
for db in $BASES
do
#On lance un check et une analyse pour chaque base de données
$MYSQLCHECK -u $user -h $host -p$pass -c -a $db
# On lance un mysqldump pour chaque base de données
$MYSQLDUMP -u $user -h $host -p$pass $OPTIONS $db -R > $TEMPORAIRE"/"$MACHINE"-"$db"-"$DATE".sql";
done

# Création de l'archive contenant tout les dump
#Cette archive est stockée dans le dossier défini pour la sauvegarde
if [ -d $DESTINATION ];
then
cd $TEMPORAIRE
tar -cvzf $DESTINATION"/"$FICHIER_BACKUP *
fi

# On transfere l'archive par FTP
cd $DESTINATION
ftp -v -n $HOST_FTP < <SCRIPT
user $LOGIN_FTP $PASS_FTP
bin
put $FICHIER_BACKUP
bye
SCRIPT

# On supprime le fichier de plus de x jours
if [ -f $DESTINATION"/"$FICHIER_EFFACER ]; then
rm $DESTINATION"/"$FICHIER_EFFACER
fi

# On suprime le répertoire temporaire
if [ -d fichier ]; then
rm -Rf $TEMPORAIRE
fi

Sauvegarde incrémentale des fichiers avec rsync

Je sauvegarde mes fichiers à la semaine de la façon suivante :

sauvegarde dans un répertoire nommé : -
dans ce répertoire j’ai un dossier main qui contient l’intégralité des fichiers. Cette sauvegarde est faite le lundi.
j’ai 6 répertoires nommés : _ contenant les sauvegardes incrémentales de la semaine.

J’ai modifié le script pour ajouter une conservation des sauvegardes de 4 semaines.

#!/bin/bash

# - By default, the full backup is made monday, you can specify another day
# by entering a number from 1 to 7 (1 is monday, 2 is tuesday ...)
#FULL_DAY=1

# - BACKUP_LIST is a text file where you specify files/directories you
# want to backup (one per line), the paths on this file must be relative
# to the path set in BACKUP_ROOT
BACKUP_ROOT=/
BACKUP_LIST="/home/backuper/scripts/backup_list_files"

# Excludes file
# - Contains one wildcard pattern per line of files to exclude
# - This is a rsync exclude file. See the rsync man page.
EXCLUDES_LIST="/home/backuper/scripts/backup_exclude_files"

# Hostname or IP adress of the remote backup server
BACKUP_SRV=

# Port SSH
SSH_PORT=

# Root directory that stores backups on the remote server
ARCHIVE_ROOT=~/files

# Remote user. Used by ssh. This is the user who connects to the remote backup server
# Must have write access on $ARCHIVE_ROOT
REMOTE_USER=

# Mail address for status updates
# - This is used to email you a status report
# - Comment it if you don't want to mail the report
MAILADDR=

# Log file
LOGFILE="/home/backuper/backup-files.log"

# HOSTNAME
# This is used for creating a directory specific to this host on the remote host
HOSTNAME="$(hostname)"

#########################################
# From here on out, you probably don't #
# want to change anything unless you #
# know what you're doing. #
#########################################

if [ -f $LOGFILE ]
then
rm $LOGFILE
touch $LOGFILE
fi

# Calculate WEEK_NUM
# - This is the week number of year, it depends on the variable FULL_DAY
# the value of FULL_DAY is considered as the first day of week
# - By default the command `date +%W` considers monday as first day of week, so if the day of
# the full backup is different from monday then we must make additional operations
if [ $FULL_DAY ] && [ $FULL_DAY -le 7 ] && [ `date +%u` -ge $FULL_DAY ] ; then
WEEK_NUM=`expr $(date +%W) + 1`
else
WEEK_NUM=`date +%W`
fi

# ARCHIVE_DIR
# This is the directory (full path) of the current week backups (on the remote host)
# The name of directory indicates the number of the week in the year (e.g 2007-32)
ARCHIVE_DIR="$ARCHIVE_ROOT/$HOSTNAME/`date +%Y`-$WEEK_NUM"

# Directory which holds our current datastore
CURRENT=main

# Directory which we save incremental changes to (e.g monday_06-08-2007)
INCREMENTDIR=`date +%A_%d-%m-%Y`

# Options to pass to rsync
# -r for recursivity must be explicite in spite of -a because --files-from (see man rsync)
OPTIONS="--force --ignore-errors --delete --delete-excluded \
--exclude-from=$EXCLUDES_LIST --backup --backup-dir=$ARCHIVE_DIR/$INCREMENTDIR \
-arhv --files-from=$BACKUP_LIST"

# Our actual rsyncing function
do_rsync()
{
if [ $SSH_PORT ] ; then
rsync -e "ssh -p $SSH_PORT" $OPTIONS $BACKUP_ROOT $REMOTE_USER@$BACKUP_SRV:$ARCHIVE_DIR/$CURRENT >> $LOGFILE 2>&1
else
rsync $OPTIONS $BACKUP_ROOT $REMOTE_USER@$BACKUP_SRV:$ARCHIVE_DIR/$CURRENT >> $LOGFILE 2>&1
fi
return
}

# Our post rsync accounting function
do_accounting()
{
if [ $1 ] ; then
echo "Backup accounting for day $INCREMENTDIR on $HOSTNAME:" > /tmp/rsync_script_tmpfile
echo >> /tmp/rsync_script_tmpfile

if [ $SSH_PORT ] ; then
ssh -p $SSH_PORT $REMOTE_USER@$BACKUP_SRV du -s $ARCHIVE_DIR/* >> /tmp/rsync_script_tmpfile
else
ssh $REMOTE_USER@$BACKUP_SRV du -s $ARCHIVE_DIR/* >> /tmp/rsync_script_tmpfile
fi

echo >> /tmp/rsync_script_tmpfile
cat $LOGFILE | grep "rsync: " >> /tmp/rsync_script_tmpfile

echo "Mail $1 -s "$HOSTNAME Backup Report" < /tmp/rsync_script_tmpfile"
mail $1 -s "$HOSTNAME Backup Report" < /tmp/rsync_script_tmpfile

echo "rm /tmp/rsync_script_tmpfile"
rm /tmp/rsync_script_tmpfile
fi
}

# Clean old backups
do_clean()
{
# Nb weeks
NB_WEEKS_MAX=4
LIMIT=`expr $WEEK_NUM - $NB_WEEKS_MAX`

if [ $LIMIT -le 0 ]
then
NB=`expr $NB_WEEKS_MAX - $WEEK_NUM`
NB=`expr 52 - $NB`
LAST_YEAR=`expr $(date +%Y) - 1`
TO_DELETE_DIR="$ARCHIVE_ROOT/$HOSTNAME/$LAST_YEAR-$NB"

if [ -d $TO_DELETE_DIR ] ; then
echo "rm -rf $TO_DELETE_DIR"
rm -rf $TO_DELETE_DIR
fi
else
TO_DELETE_DIR="$ARCHIVE_ROOT/$HOSTNAME/`date +%Y`-$LIMIT"

if [ -d $TO_DELETE_DIR ] ; then
echo "rm -rf $TO_DELETE_DIR"
rm -rf $TO_DELETE_DIR
fi
fi
}

# Some error handling and/or run our backup and accounting
if [ $BACKUP_LIST ]; then
if [ $EXCLUDES_LIST ]; then
if [ -f $BACKUP_LIST ]; then
if [ -f $EXCLUDES_LIST ] ; then
# make sure our backup tree exists
if [ $SSH_PORT ] ; then
ssh -p $SSH_PORT $REMOTE_USER@$BACKUP_SRV install -d $ARCHIVE_DIR/$CURRENT
else
ssh $REMOTE_USER@$BACKUP_SRV install -d $ARCHIVE_DIR/$CURRENT
fi
echo >> $LOGFILE
echo "=========================================================" >> $LOGFILE
echo "`date` : Backup started." >> $LOGFILE
do_rsync
if [ $? -eq 0 ] ; then
echo "OK. Backup succeeded" | tee -a $LOGFILE
do_clean
do_accounting $MAILADDR
exit 0
else
echo "Backup failed. See $LOGFILE for debug info." | tee -a $LOGFILE
do_accounting $MAILADDR
exit 1
fi
else
echo "$EXCLUDES_LIST: File not found or not a regular file. Backup aborted" | tee -a $LOGFILE;
exit 1
fi
else
echo "$BACKUP_LIST: File not found or not a regular file. Backup aborted" | tee -a $LOGFILE
exit 1
fi
else
echo "You must edit the script file and set the variable EXCLUDES_LIST" | tee -a $LOGFILE
exit 1
fi
else
echo "You must edit the script file and set the variable BACKUP_LIST" | tee -a $LOGFILE
exit 1
fi

exit 2

Je sauvegarde ces fichiers :

var/www
var/log
etc/apache2
etc/apt/sources.list
etc/fstab
etc/crontab
etc/hostname
etc/hosts
etc/group
etc/memcached.conf
etc/mysql
etc/nginx
etc/php5
etc/phpmyadmin
etc/postfix
etc/ssh
etc/fail2ban
home

Et j’exclue ceux-là :

home/backuper/backup-files.log
home/backuper/files
etc/mysql/debian.cnf
etc/ssh/ssh_host*
etc/phpmyadmin/htpasswd.setup
.*_history
.Xauthority
.lesshst
.ssh

Automatisation

J’ai rajouté dans mon crontab, deux lignes pour lancer les sauvegardes différées de 2h :

0 1 * * * /home/backuper/scripts/backup_mysql.sh
0 3 * * * /home/backuper/scripts/backup_files.sh

Gravatar : De beaux avatars dans les commentaires

Will — Tue, 26 May 2009 17:51:01 +0000

Gravatar pour Globally Recognized Avatar est un service qui permet d’utiliser un avatar sur les sites WordPress en identifiant l’email de la personne qui a écrit.

Je me suis souvent demandé comment, sans enregistrement, certaines personnes avaient leur avatar dans les commentaires d’un blog mais je n’ai jamais pris la peine de chercher plus.

C’est aujourd’hui chose faite, et j’ai intégré tout ça dans mon blog.

L’intégration est très aisée. Elle est basée sur cet article : http://www.wordpress-fr.net/blog/wordpress/integrer-gravatar-sans-plugin.

Il m’a suffit de rajouter un champs email dans le formulaire d’ajout d’un commentaire.

Ensuite j’ai modifié un peu le template en testant si ce champs est nul ou non. S’il n’est pas nul, je tente de charger l’avatar depuis Gravatar. L’identification au service Gravatar se fait simplement avec le hash md5 de l’email :

p style= »text-align: justify; »>Et voilà comment obtenir un peu plus d’ergonomie dans les commentaires, et ceci sans devoir créer une zone membre ou autre. C’est complètement transparent pour l’utilisateur, je trouve ça génial.Related Posts

API Google Analytics – Une classe PHP5 et des résultats d’intégration

Will — Mon, 27 Apr 2009 11:42:35 +0000

Pour intégrer Google Analytics à mon système de blog je me suis constitué une petite classe PHP5. Cette classe est implémentée selon le design pattern Singleton. Le constructeur dispose des identifiants de connexion en dur mais on peut très bien utiliser des constantes.

class GAnalytics
{
private $email;
private $passwd;
private $ids;
private $auth;
private static $instance;

private function __construct()
{
$this->login('********@********', '********', '********');
}

private function __clone()
{}

public static function instance()
{
if(!isset(self::$instance))
{
$c = __CLASS__;
self::$instance = new $c;
}

return self::$instance;
}

private function login($email, $passwd, $ids)
{
$this->email = $email;
$this->passwd = $passwd;
$this->ids = $ids;

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = array('accountType' => 'GOOGLE',
'Email' => $this->email,
'Passwd' => $this->passwd,
'source'=>'CLI_GAnalytics',
'service'=>'analytics');

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$hasil = curl_exec($ch);
$hasil = @split("Auth=", $hasil);
curl_close($ch);

$this->auth = $hasil[1];
}

public function getDimensionByMetric($metrics, $dimensions, $date_1, $date_2 = null)
{
if(!$date_2)
$date_2 = $date_1;

$ch = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $this->ids . "&metrics=ga:" . $metrics . "&dimensions=ga:" . $dimensions . "&start-date=" . $date_1 . "&end-date=" . $date_2);

$header[] = 'Authorization: GoogleLogin auth=' . $this->auth;

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);

$response = curl_exec($ch);
$infos = curl_getinfo($ch);
curl_close($ch);

if($infos['http_code'] != 200)
throw new Exception("[EXCEPTION] (" . $info['http_code'] . ") " . $response);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

$data = '';
$label = '';
foreach($XML_object->entry as $m)
{
$tmp = @split('ga:' . $dimensions . '=', $m->title);

if($label == "")
{
$label .= $tmp[1] . ' (' . $m->metric['value'] . ')';
$data .= $m->metric['value'];
}
else
{
$label .= '|' . $tmp[1] . ' (' . $m->metric['value'] . ')';
$data .= ',' . $m->metric['value'];
}
}

return array('label' => $label, 'data' => $data);
}

public function getMetric($metric, $date_1, $date_2 = null)
{
if(!$date_2)
$date_2 = $date_1;

$ch = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $this->ids . "&metrics=ga:" . $metric . "&start-date=" . $date_1 . "&end-date=" . $date_2);

$header[] = 'Authorization: GoogleLogin auth=' . $this->auth;

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);

$response = curl_exec($ch);
$infos = curl_getinfo($ch);
curl_close($ch);

if($infos['http_code'] != 200)
throw new Exception("[EXCEPTION] (" . $info['http_code'] . ") " . $response);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

return $XML_object->entry->metric['value'] ? $XML_object->entry->metric['value'] : 0;
}

public function getMetricURI($metric, $uri, $date_1, $date_2 = null)
{
if(!$date_2)
$date_2 = $date_1;

$ch = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $this->ids . "&metrics=ga:" . $metric . "&dimensions=ga:pagePath&filters=ga:pagePath=" . $uri . "&start-date=" . $date_1 . "&end-date=" . $date_2);

$header[] = 'Authorization: GoogleLogin auth=' . $this->auth;

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);

$response = curl_exec($ch);
$infos = curl_getinfo($ch);
curl_close($ch);

if($infos['http_code'] != 200)
throw new Exception("[EXCEPTION] (" . $info['http_code'] . ") " . $response);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

return $XML_object->entry->metric['value'] ? $XML_object->entry->metric['value'] : 0;
}
}

?>

Pour récupérer une instance de cette classe on appelle la méthode statique instance() :

$ga = GAnalytics::instance();

Ensuite on peut utiliser les méthodes comme dans l’exemple ci-dessous :

$navigateurs = $ga->getDimensionByMetric('visits', 'browser', date('Y-m-d', time()));
$countries = $ga->getDimensionByMetric('visits', 'country', date('Y-m-d', time()));
$visits = $ga->getMetric('visits', date('Y-m-d', time()));
$unique_visits = $ga->getMetric('visitors', date('Y-m-d', time()));
$page_views = $ga->getMetric('pageviews', date('Y-m-d', time()));

getDimensionByMetric() permet d’effectuer une requête avec un metric et une dimension.
getMetric() permet d’effectuer une requête avec un metric uniquement.
getMetricURI() permet d’effectuer une requête avec un metric par rapport à une URI précise.

On passe soit un intervalle (une période), soit une seule date.

Cette classe et ces méthodes sont très perfectibles, mais elles me suffisent amplement pour une intégration basique de Google Analytics. Ceci m’a permis d’avoir le résultat suivant :

L’image ci-dessus présente ma page de statistiques dans ma partie administrateur du blog. On peut voir le nombre de visites au total, le nombre de pages vues et le nombres de visiteurs uniques, le tout sur la journée. J’ai aussi deux graphiques représentant les visites par navigateur et par pays.

L’image ci-dessus représente l’intégration de Google Analytics pour chacun de mes articles. On peut y voir le nombre de fois que cet article a été affiché, le nombre de consultations uniques ainsi que le temps moyen passé sur cet article, le tout sur la journée.

Liens annexes :

http://www.willdurand.fr/api-google-analytics-decouverte-par-l-exemple/

http://www.willdurand.fr/api-google-analytics-round-2-graphiques-et-statistiques-par-page/

API Google Analytics Round 2 – Graphiques et statistiques par page

Will — Thu, 23 Apr 2009 18:03:16 +0000

Après mes premiers essais d’hier, et mes idées d’implémentation dans mon système de blog, je me suis mis à l’oeuvre. J’ai donc ajouté un rendu au code d’hier (avec la librairie graphique de Google ici) et mis en place pour chacun de mes articles, des statistiques journalières.

Graphique avec l’API Google Chart

L’API Google Chart est une API qui permet de créer des graphiques (format image) assez simplement. Le lien qui m’a été utile est le suivant : http://code.google.com/intl/fr/apis/chart/basics.html. J’avais commencé avec Yahoo UI que j’utilise régulièrement au travail, mais l’intérêt était moindre et je voulais consommer le moins de ressources possibles. Cependant YUI permet d’avoir des graphiques live, ce qui peut avoir son utilité.

Donc j’ai repris le code d’hier, je l’ai modifié un petit peu et voilà le résultat :

$email = '*******@*******';
$passwd = '*******';
$ids = '*******';

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = array('accountType' => 'GOOGLE',
'Email' => $email,
'Passwd' => $passwd,
'source'=>'CLI_GAnalytics',
'service'=>'analytics');

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$hasil = curl_exec($ch);
$hasil = @split("Auth=", $hasil);
$auth = $hasil[1];

curl_close($ch);

$current_date = date('Y-m-d', time());
$ch1 = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:visits&dimensions=ga:browser&start-date=" . $current_date . "&end-date=" . $current_date);

$header[] = 'Authorization: GoogleLogin auth=' . $auth;

curl_setopt($ch1, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch1, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch1, CURLOPT_HEADER, false);

$response = curl_exec($ch1);
curl_close($ch1);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

$data = '';
$label = '';
foreach($XML_object->entry as $m)
{
$tmp = @split('ga:browser=', $m->title);
if($label == "")
{
$label .= $tmp[1] . ' (' . $m->metric['value'] . ')';
$data .= $m->metric['value'];
}
else
{
$label .= '|' . $tmp[1] . ' (' . $m->metric['value'] . ')';
$data .= ',' . $m->metric['value'];
}
}

echo '
chs=400x150
&chd=t:' . $data . '
&cht=p3
&chdl=' . $label . '"
alt="Sample chart" />
';

?>

Ce qui permet d’obtenir ce genre de graphique :

Résultat très honorable pour la très faible complexité de ce code. J’ai donc mon graphique des navigateurs sur la journée. Le nombre entre parenthèses correspond au nombre de visites avec le dit navigateur.

Statistiques par page

Je voulais pouvoir voir mes statistiques par page, en administrateur seulement. C’est-à-dire avoir à côté de mes liens d’édition et pour chaque article, le nombre de fois que mon article a été vu aujourd’hui et combien il y a eu de visites uniques.

C’est maintenant chose faite, et c’est facile !

$email = '********@********';
$passwd = '********';
$ids = '********';

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = array('accountType' => 'GOOGLE',
'Email' => $email,
'Passwd' => $passwd,
'source'=>'CLI_GAnalytics',
'service'=>'analytics');

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$hasil = curl_exec($ch);
$hasil = @split("Auth=", $hasil);
$auth = $hasil[1];

curl_close($ch);

$uri = $_SERVER['REQUEST_URI'];

$current_date = date('Y-m-d', time());
$ch1 = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:pageviews&dimensions=ga:pagePath&filters=ga:pagePath%3D%3D" . $uri . "&start-date=" . $current_date . "&end-date=" . $current_date);

$header[] = 'Authorization: GoogleLogin auth=' . $auth;

curl_setopt($ch1, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch1, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch1, CURLOPT_HEADER, false);

$response = curl_exec($ch1);
curl_close($ch1);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

$pv = $XML_object->entry->metric['value'] ? $XML_object->entry->metric['value'] : 0;

echo 'Vue ' . $pv . ' fois aujourd\'hui.';

?>

J’ai donc mon résultat de la forme :

Vue 10 fois aujourd'hui.

Ce qu’il fallait faire pour récupérer les informations de la page courante et ce qui fait l’intérêt de l’article :

$ch1 = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:pageviews&dimensions=ga:pagePath&filters=ga:pagePath%3D%3D" . $uri . "&start-date=" . $current_date . "&end-date=" . $current_date);

Ou plus exactement ajouter la dimension pagePath et filtrer sur cette dimension comme ceci :

&filters=ga:pagePath%3D%3D" . $uri . "

L’URI de la page se récupère avec :

$_SERVER['REQUEST_URI']

On récupère par exemple : /index.html.

Pour avoir la même chose avec les visites uniques, il suffit de modifier le metrics en uniquepageviews.

L’utilisation des filtres c’est par ici. Tous les metrics et dimensions sont par là.

Voilà pour ce petit article, on peut faire des choses très puissantes, très simplement, on peut imaginer améliorer son référencement automatiquement en récupérant les infos Google Analytics et en agissant en fonction, cela en toute transparence pour le visiteur comme pour l’utilisateur.

API Google Analytics, découverte par l’exemple

Will — Wed, 22 Apr 2009 22:19:10 +0000

Aujourd’hui Google a mis au jour sa nouvelle API, il s’agit de l’API Google Analytics tant attendue. L’annonce officielle se trouve ici. J’ai donc sauté sur l’occasion pour pondre quelques petits scripts PHP et pouvoir par la suite intégrée Google Analytics à mon système de blog.

Cette API est utilisable en JavaScript, PHP, ou encore Java. En PHP, on peut utiliser cette API avec Zend (ici) ou avec Curl. C’est ce dernier que j’ai utilisé dans ce qui suit.

I – Authentification

Il faut être authentifié pour utiliser cette API, Google offre, comme pour ses autres services, plusieurs possibilités. Je passerais les explications lourdes sur les différents modes d’authentification (lire ici). Ce qu’il faut au final, c’est récupéré un Token qui permettra d’utiliser le service Google Analytics par la suite.

Je voulais un système d’authentification où l’on ai juste à renseigner ses identifiants Google.

$email = '*********@*********';
$passwd = '********';
$ids = '********';

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = array('accountType' => 'GOOGLE',
'Email' => $email,
'Passwd' => $passwd,
'source'=>'CLI_GAnalytics',
'service'=>'analytics');

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$hasil = curl_exec($ch);
$hasil = @split("Auth=", $hasil);
$auth = $hasil[1];

curl_close($ch);

Donc j’ai utilisé Curl, ce qui a nécessité l’activation du module PHP (dans WAMP).

$ids représente l’identifiant du site concerné. Il est à récupérer dans Google Analytics, il suffit d’ouvrir le dashboard du site et de regarder l’identifiant dans l’url qui se présente ainsi : https://www.google.com/analytics/reporting/?id=xxxxxxxxx.

On passe ensuite les données dans un tableau, en sachant que vous pouvez mettre ce que vous voulez dans ‘source’.

$auth est mon Token d’authentification auprès du service Google Analytics.

II – Récupération des informations

Je désire afficher, pour le jour courant (oui parce que l’API permet de récupérer les informations de son site en direct), le nombre de visites par navigateur.

$current_date = date('Y-m-d', time());
$ch1 = curl_init("https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:visits&dimensions=ga:browser&start-date=" . $current_date . "&end-date=" . $current_date);

$header[] = 'Authorization: GoogleLogin auth=' . $auth;

curl_setopt($ch1, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch1, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch1, CURLOPT_HEADER, false);

$response = curl_exec($ch1);
curl_close($ch1);

$XML_response = @str_replace('dxp:','',$response);
$XML_object = simplexml_load_string($XML_response);

echo '

;

foreach

(

$XML_object

entry

)

{

$tmp

split

(

'ga:browser='

title

)

;

echo

' . $tmp[1];
echo ' : ';
echo $m->metric['value'];
echo ' visits

;

}

echo

Lorsqu’on veut utiliser l’API il faut indiquer que l’on est authentifié, c’est le but des lignes :

$header[] = 'Authorization: GoogleLogin auth=' . $auth;
curl_setopt($ch1, CURLOPT_HTTPHEADER, $header);

Ensuite, il est obligatoire de renseigner les paramètres ids, start-date et end-date. Sinon on obtient une belle erreur… Ici, je cherche à récupérer le nombre de visites (qui est le metric) en fonction du navigateur qui est la dimension.

https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:visits&dimensions=ga:browser&start-date=" . $current_date . "&end-date=" . $current_date);

Les metrics et dimensions sont disponibles ici.

On récupère un flux XML, que j’ai d’abord épuré :

$XML_response = @str_replace('dxp:','',$response);

Puis je charge un objet XML pour récupérer les résultats que je souhaite.

Ce code produit le résultat suivant :

Chrome : 1 visits
Firefox : 15 visits
Internet Explorer : 3 visits

Youpi ! Je suis riche, 19 visites aujourd’hui…

Pour récupérer le nombre de visiteurs, il suffit de modifier les metrics et dimensions :

https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:visits&start-date=" . $current_date . "&end-date=" . $current_date);

et de changer l’accès au résultat :

echo $XML_object->entry->metric['value'] . ' visits';

Pour récupérer le nombre de pages vues, on modifie comme ceci (l’accès au résultat est le même) :

https://www.google.com/analytics/feeds/data?ids=ga:" . $ids . "&metrics=ga:pageviews&start-date=" . $current_date . "&end-date=" . $current_date);

III – Le mot de la fin

Cette API est très intéressante et très simple à mettre en oeuvre. La documentation est claire et il y en a beaucoup.

Pour la suite, il peut être intéressant d’avoir ce genre de statistiques dans l’administration de son site ou de naviguer en administrateur et de pouvoir voir sur chacun de ses articles de telles statistiques.

Pour moi, ce sera cette dernière idée qui sera mise en place .

Sources : http://google-data-api.blogspot.com/2008/05/clientlogin-with-php-curl.html pour l’utilisation de Curl, et l’API Google pour le reste.

Découverte des WebServices en PHP

Will — Thu, 16 Apr 2009 17:57:29 +0000

Et oui, en PHP on peut faire des webservices. Mais un WebService c’est quoi d’abord ?

C’est un programme sur Internet qui permet la communication et l’échange de données entre applications. Ce sont des fonctionnalités, des services mis à disposition sur Internet (ou Intranet) et accessibles par tout le monde.

C’est interopérable, c’est basé sur HTTP (donc pas de soucis au niveau des parefeux), on utilise des standards et des protocoles ouverts, et c’est l’avenir du web. Bref, puissant !

Principe de fonctionnement

Dans l’exemple illustré, le Client veut savoir le temps qu’il fait.

- En 1, Il va demandé à un annuaire de webservices (UDDI) où il peut trouver un tel service.

- En 2, l’annuaire lui indique où est le service qui pourra le renseigner.

- En 3, le client demande au service comment l’invoquer (c’est-à-dire comment bien lui demander un service).

- En 4, le service renvoit sa déscription (WSDL) où est indiqué comment invoquer ce service.

- En 5, le client invoque le service en envoyant une requête SOAP.

- En 6, le service renvoit la réponse au client dans une réponse (toujours en SOAP).

Un service web en PHP

En PHP, on peut faire des webservices, que ce soit en tant que client ou en tant que serveur comme je vais expliquer dans ce qui suit. Il faudra préalablement avoir le module php_soap installé et activé.

Mon webservice sera simple, il disposera de deux méthodes :

- La première se nommera hello() et retournera « Hello world! ».

- La deuxième s’appellera donne(), prendra une variable en attribut et la retournera.

class Donne
{
function donne($i)
{
return $i;
}
function hello()
{
return "hello world";
}
}

La classe ci-dessus représente les fonctionnalités de mon webservice. Il s’agit maintenant de le mettre en place, c’est que fait le code ci-après :

try
{
$server = new SoapServer(null, array('uri' => 'http://monserveur/ws/mon_premier_webservice.php'));

$server->setClass("Donne");
$server->handle();
}
catch(Exception $e)
{
echo "Exception: " . $e;
}

On commence par créer un objet SoapServer qui prend en arguments un fichier WSDL (null ici) et une liste de paramètres. Si le fichier WSDL n’est pas renseigné comme ici, il faut obligatoirement spécifier le paramètre URI ensuite.

Ensuite, on va indiquer à notre serveur, la classe qui gère les requêtes SOAP par la méthode setClass(). La méthode handle() fait le nécessaire pour gérer une requête SOAP.

Voilà c’est tout, pour être disponible, il faut placer notre service à l’adresse : http://monserveur/ws/mon_premier_webservice.php.

L’URI qui représente l’espace de nom, est différente de la Location du service qui est l’URL à interroger.

Un client pour mon premier webservice

L’utilité d’un webservice, c’est de pouvoir l’exploiter. On va donc développer un petit client en PHP pour invoquer notre service web précédemment écrit.

Voici le code de notre petit client :

try
{
$clientSOAP = new SoapClient( null,
array (
'uri' => 'http://monserveur/ws/mon_premier_webservice.php',
'location' => 'http://monserveur/ws/mon_premier_webservice.php',
'trace' => 1,
'exceptions' => 0
));

$ret = $clientSOAP->__call('hello', array());
echo $ret;

echo '
';

$ret = $clientSOAP->__call('donne', array('i'=>5));
echo $ret;
}
catch(SoapFault $f)
{
echo $f;
}

?>

Ce code teste les deux méthodes de notre service. On crée cette fois-ci un SoapClient.

On travaille toujours en mode non WSDL, il faut passer obligatoirement deux paramètres qui sont URI et Location. Trace et Exception sont utiles lorsqu’un problème survient.

Pour appeler une méthode, on utilise la méthode __call(). Pour passer les paramètres à une fonction, il suffit de passer un tableau associatif.

Et voilà, ce n’est finalement pas si compliqué !

Un client plus élaboré pour un service Whois

Pour étoffer cet article, voici un exemple d’utilisation des webservices. Sur le site http://www.xmethods.net/ qui présente des services web, j’ai choisi un service Whois. Le site donne le lien de la description WSDL du service web. C’est tout ce dont nous avons besoin.

Présentation du web service :

Whois service lets users get domain information from any registry.

Servername is the whois server to be used.Some commonly queried whois servers are:- whois.networksolutions.com- whois.35.com- whois.tucows.com

Port is always 43 for whois servers.Domain is the domain name that you want to query.

La description WSDL de notre service Whois est disponible ici : http://www.ecubicle.net/whois_service.asmx?WSDL, voici ce que l’on récupère :

version="1.0" encoding="utf-8"?>
="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://www.ecubicle.net/webservices/" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" targetNamespace="http://www.ecubicle.net/webservices/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">

="qualified" targetNamespace="http://www.ecubicle.net/webservices/">
name="HelloWorld">
/>
</s:element>
name="HelloWorldResponse">

="0" maxOccurs="1" name="HelloWorldResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
name="Whois">

="0" maxOccurs="1" name="servername" type="s:string" />
="1" maxOccurs="1" name="port" type="s:unsignedByte" />

="0" maxOccurs="1" name="domain" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
name="WhoisResponse">

="0" maxOccurs="1" name="WhoisResult" type="s:string" />
</s:sequence>

</s:complexType>
</s:element>
name="string" nillable="true" type="s:string" />
</s:schema>
</wsdl:types>
name="HelloWorldSoapIn">
name="parameters" element="tns:HelloWorld" />
</wsdl:message>
name="HelloWorldSoapOut">

name="parameters" element="tns:HelloWorldResponse" />
</wsdl:message>
name="WhoisSoapIn">
name="parameters" element="tns:Whois" />
</wsdl:message>
name="WhoisSoapOut">
name="parameters" element="tns:WhoisResponse" />
</wsdl:message>
name="HelloWorldHttpGetIn" />

name="HelloWorldHttpGetOut">
name="Body" element="tns:string" />
</wsdl:message>
name="WhoisHttpGetIn">
name="servername" type="s:string" />
name="port" type="s:string" />
name="domain" type="s:string" />
</wsdl:message>
name="WhoisHttpGetOut">

name="Body" element="tns:string" />
</wsdl:message>
name="HelloWorldHttpPostIn" />
name="HelloWorldHttpPostOut">
name="Body" element="tns:string" />
</wsdl:message>
name="WhoisHttpPostIn">
name="servername" type="s:string" />
name="port" type="s:string" />

name="domain" type="s:string" />
</wsdl:message>
name="WhoisHttpPostOut">
name="Body" element="tns:string" />
</wsdl:message>
name="whois_serviceSoap">
name="HelloWorld">
="tns:HelloWorldSoapIn" />
="tns:HelloWorldSoapOut" />

</wsdl:operation>
name="Whois">
="http://schemas.xmlsoap.org/wsdl/">Whois service lets users get domain information from any registry. <br/><h4> Servername</h4> is the whois server to be used.<br/>Some commonly queried whois servers are: <br/><ul><li>whois.networksolutions.com</li><li>whois.35.com</li><li>whois.tucows.com</li></ul> <br/><br/><h4> Port </h4>is always 43 for whois servers. <br/><br/><h4>Domain </h4><br/>is the domain name that you want to query.</wsdl:documentation>

="tns:WhoisSoapIn" />
="tns:WhoisSoapOut" />
</wsdl:operation>
</wsdl:portType>
name="whois_serviceHttpGet">
name="HelloWorld">
="tns:HelloWorldHttpGetIn" />
="tns:HelloWorldHttpGetOut" />
</wsdl:operation>

name="Whois">
="http://schemas.xmlsoap.org/wsdl/">Whois service lets users get domain information from any registry. <br/><h4> Servername</h4> is the whois server to be used.<br/>Some commonly queried whois servers are: <br/><ul><li>whois.networksolutions.com</li><li>whois.35.com</li><li>whois.tucows.com</li></ul> <br/><br/><h4> Port </h4>is always 43 for whois servers. <br/><br/><h4>Domain </h4><br/>is the domain name that you want to query.</wsdl:documentation>

="tns:WhoisHttpGetIn" />
="tns:WhoisHttpGetOut" />
</wsdl:operation>
</wsdl:portType>
name="whois_serviceHttpPost">
name="HelloWorld">
="tns:HelloWorldHttpPostIn" />
="tns:HelloWorldHttpPostOut" />
</wsdl:operation>

name="Whois">
="http://schemas.xmlsoap.org/wsdl/">Whois service lets users get domain information from any registry. <br/><h4> Servername</h4> is the whois server to be used.<br/>Some commonly queried whois servers are: <br/><ul><li>whois.networksolutions.com</li><li>whois.35.com</li><li>whois.tucows.com</li></ul> <br/><br/><h4> Port </h4>is always 43 for whois servers. <br/><br/><h4>Domain </h4><br/>is the domain name that you want to query.</wsdl:documentation>

="tns:WhoisHttpPostIn" />
="tns:WhoisHttpPostOut" />
</wsdl:operation>
</wsdl:portType>
name="whois_serviceSoap" type="tns:whois_serviceSoap">
="http://schemas.xmlsoap.org/soap/http" />
name="HelloWorld">
="http://www.ecubicle.net/webservices/HelloWorld" style="document" />

="literal" />
</wsdl:input>

="literal" />
</wsdl:output>
</wsdl:operation>
name="Whois">
="http://www.ecubicle.net/webservices/Whois" style="document" />

="literal" />
</wsdl:input>

="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
name="whois_serviceSoap12" type="tns:whois_serviceSoap">
="http://schemas.xmlsoap.org/soap/http" />

name="HelloWorld">
="http://www.ecubicle.net/webservices/HelloWorld" style="document" />

="literal" />
</wsdl:input>

="literal" />
</wsdl:output>
</wsdl:operation>

name="Whois">
="http://www.ecubicle.net/webservices/Whois" style="document" />

="literal" />
</wsdl:input>

="literal" />
</wsdl:output>
</wsdl:operation>

</wsdl:binding>
name="whois_serviceHttpGet" type="tns:whois_serviceHttpGet">
="GET" />
name="HelloWorld">
="/HelloWorld" />

/>
</wsdl:input>

="Body" />
</wsdl:output>
</wsdl:operation>
name="Whois">
="/Whois" />

/>
</wsdl:input>

="Body" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
name="whois_serviceHttpPost" type="tns:whois_serviceHttpPost">
="POST" />
name="HelloWorld">
="/HelloWorld" />

content type="application/x-www-form-urlencoded" />
</wsdl:input>

="Body" />
</wsdl:output>
</wsdl:operation>
name="Whois">
="/Whois" />

content type="application/x-www-form-urlencoded" />
</wsdl:input>

="Body" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
name="whois_service">
name="whois_serviceSoap" binding="tns:whois_serviceSoap">

="http://www.ecubicle.net/whois_service.asmx" />
</wsdl:port>
name="whois_serviceSoap12" binding="tns:whois_serviceSoap12">
="http://www.ecubicle.net/whois_service.asmx" />
</wsdl:port>
name="whois_serviceHttpGet" binding="tns:whois_serviceHttpGet">
="http://www.ecubicle.net/whois_service.asmx" />
</wsdl:port>
name="whois_serviceHttpPost" binding="tns:whois_serviceHttpPost">

="http://www.ecubicle.net/whois_service.asmx" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

Seul le début nous intéresse. Par exemple, on voit que ce service propose deux fonctionnalités : HelloWorld et Whois.

- HelloWorld s’invoque sans paramètres (décrit par l’élément HelloWorld), et retourne un HelloWorldResult de type String (décrit par l’élément HelloWorldResponse).

<s:element name="HelloWorld">
<s:complexType />
s:element>
<s:element name="HelloWorldResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="HelloWorldResult" type="s:string" />
s:sequence>
s:complexType>
s:element>

- Whois s’invoque en passant un objet et retourne un WhoisResult de type String.

L’objet passé se compose de trois attributs : servername de type String, port qui est un entier non signé, et domain de type String.

name="Whois">

="0" maxOccurs="1" name="servername" type="s:string" />
="1" maxOccurs="1" name="port" type="s:unsignedByte" />
="0" maxOccurs="1" name="domain" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
name="WhoisResponse">

="0" maxOccurs="1" name="WhoisResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>

Il faudra donc une classe PHP représentant cet objet. Ensuite on va utiliser un SoapClient en mode WSDL. Le script qui suit affiche la liste des fonctionnalités du service grâce à la fonction __getFunctions(), puis invoque successivement les deux méthodes du service.

class Whois
{
private $servername;
private $port;
private $domain;

function __construct($s, $p, $d)
{
$this->servername = $s;
$this->port = $p;
$this->domain = $d;
}
}

try
{
$client = new SoapClient('http://www.ecubicle.net/whois_service.asmx?WSDL');

var_dump($client->__getFunctions());
echo '

';

echo 'Invocation de HelloWorld() :';
echo '
';

$ret = $client->__soapCall('HelloWorld', array());

print_r($ret);
echo '
';
echo $ret->HelloWorldResult;

echo '

Invocation de Whois() :';
echo '
';
$ret = $client->__soapCall('Whois', array('Whois'=>new Whois('whois.verisign-grs.com',43,'google.fr')));

echo $ret->WhoisResult;
}
catch(Exception $e)
{
echo '

';
echo "Exception: " . $e;
}

?>

Etre notifié du passage de Google sur son site

Will — Sun, 12 Apr 2009 17:46:53 +0000

pre style= »text-align: center; »>

J'ai récemment mis en ligne mon blog, et le premier soucis pour les gens dans mon cas (outre le fait d'ajouter du contenu) c'est d'être référencé. J'ai donc enregistré mon site auprès de Google.

Niveau référencement, j'ai glané le plus d'astuces possibles que j'ai réinjecté dans mon blog et ainsi pouvoir être référencé au mieux.

Ensuite j'ai enregistré mon site dans Outils pour les webmasters by Google, et j'ai attendu... Cela fait plus d'une semaine et très peu d'infos, alors je me suis dit qu'une alerte mail lorsque Google passait sur mon blog, ça pourrait être bien.

Bah voilà le script que j'ai trouvé ici http://www.protycoon.com/2008/02/19/php-be-notified-when-google-crawls-your-site/.

if(strpos($_SERVER['HTTP_USER_AGENT'], 'Googlebot') !== false)
{
$email_address = 'webmaster[AT]willdurand.fr';
mail($email_address, 'Googlebot Alert', 'The Googlebot has visited your page: ' . $_SERVER['REQUEST_URI']);
}

Je reçois un mail dès que le Googlebot passe sur l'une de mes pages. Pratique n'est-ce pas ?