%%presentation
\documentclass{beamer}
\usepackage{beamerthemetree}
%%impression
%\documentclass[a4paper,9pt]{extarticle}
%\usepackage{beamerarticle}
%%

% class FR
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[frenchb]{babel}

% image
\usepackage{graphicx}

\usecolortheme{crane}
\beamertemplatetransparentcovered

% le logo
%\logo{\includegraphics[height=1cm]{ban.png}}

\title{Formation EOLE}
\subtitle{Tronc Commun}

\author{GARETTE Emmanuel}
\institute{Cadoles}
\date{\today}

\begin{document}
\frame{\titlepage}

% == INTRO ==
%\part{la partie}
\section{Introduction}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{EOLE}
   \begin{itemize}
   \item EOLE : Ensemble Ouvert Libre et Evolutif ;
   \item projet national de serveur d'établissement scolaires et académiques ;
   \item depuis 2000 ;
   \item basé sur Ubuntu depuis 2007 sous forme de module ;
   \item objectifs :
   \begin{itemize}
    \item utilisation de logiciels libres,
    \item modulaire (évolutif, ouvert, adaptable),
    \item facile a mettre en oeuvre et a déployer,
    \item administrable à distance.
   \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Panorama des modules}
  \begin{itemize}
   \item Zéphir, gestion du parc des serveurs EOLE :
   \begin{itemize}
    \item déployer et gérer un parc de serveurs,
    \item gestion de la configuration des serveurs,
    \item la surveillance et le lancement d'action à distance ;
   \end{itemize}
   \item Sentinelle, outils graphiques de supervision des serveurs (couplé à Zéphir) :
   \begin{itemize}
    \item récupération des statistiques,
    \item affichage sélectif (avec filtre, ...),
    \item lancement d'actions ;
   \end{itemize}
   \item Amon, la passerelle pare-feu :
   \begin{itemize}
    \item partage des sous-réseaux et connexion à internet (pare-feu),
    \item authentifications des utilisateurs,
    \item réseau virtuel privé,
    \item cache web,
    \item reverse proxy web ;
   \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Panorama des modules}
  \begin{itemize}
   \item Sphynx, concentrateur pour réseau privé virtuel :
   \begin{itemize}
    \item relier en réseau vos serveurs (RVP),
    \item possibilité de haute dispo ;
   \end{itemize}
   \item AmonEcole, solution virtuelle basé sur Amon :
   \begin{itemize}
    \item virtualisation sur la base de conteneur OpenVZ,
    \item Amon en serveur maître,
    \item conteneur possible : Scribe, Horus, Eclair ou EoleBase ;
   \end{itemize}
   \item EoleVZ, solution de virtualisation EOLE :
   \begin{itemize}
    \item virtualisation sur la base de conteneur OpenVZ,
    \item conteneur possible : Scribe, Horus, Eclair ou EoleBase ;
   \end{itemize}
   \item Horus, serveur administratif et Scribe, serveur pédagogique :
   \begin{itemize}
    \item partage de fichiers,
    \item partage d'imprimantes,
    \item gestion de comptes utilisateurs et de groupes,
    \item gestion des accès utilisateurs,
    \item gestion des postes clients ;
   \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Panorama des modules}
  \begin{itemize}
   \item Eclair, serveur de client léger sous GNU/Linux :
   \begin{itemize}
    \item serveur de clients légers,
    \item compatible partage de fichier Scribe et Horus,
    \item début de support de ESU,
    \item gestion de profil GNOME ;
   \end{itemize}
   \item clientscribe et clienthorus, client GNU/Linux ;
   \begin{itemize}
    \item reprend la partie "cliente" de Eclair,
   \end{itemize}
   \item ZéphirLog, concentrateur de fichiers journaux :
   \begin{itemize}
    \item remontée des logs,
    \item stockage des logs,
    \item archivage des logs ;
   \end{itemize}
   \item PreludeManager, console de visualisation de l'IDS Prélude :
   \begin{itemize}
    \item suivi détailé de la navigation web,
    \item detection d'intrusions,
    \item interface analyse des logs,
    \item statistiques ;
   \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Panorama des modules}
  \begin{itemize}
   \item Seshat, le relais de messagerie pour les domaine intra-académiques des Scribe :
   \begin{itemize}
    \item relai de messagerie académique.
   \end{itemize}
  \end{itemize}
\end{frame}

\section{Les quatre phases}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{La phase d'installation}
  \begin{itemize}
   \item Pour installer un module, il suffit de :
   \begin{itemize}
    \item démarrer sur le CD-ROM téléchargé sur le site d'EOLE,
    \item sélectionner le module à installer parmi ceux proposés,
    \item valider ;
   \end{itemize}
   \item cas particuliers : Eolebase ou la présence de deux disques ;
   \item à la fin de l'installation, cliquer sur "continuer", le système redémarre automatiquement ;
   \item vous pourrez ouvrir une session avec l'utilisateur "root" et le mot de passe par défaut "eole".
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{La phase de configuration}
  \begin{itemize}
   \item Il faut une bonne connaissance du réseau ;
   \item en mode autonome :
   \begin{itemize}
    \item lancer la commande gen\_config,
    \item configurer le serveur,
    \item sauvegarder le fichier zephir.eol ;
   \end{itemize}
   \item en mode Zéphir :
   \begin{itemize}
    \item configuration dans l'application Zéphir : https://<nom\_du\_serveur>:8070/ ou via gen\_config,
    \item enregistrement au Zéphir,
    \item descente ou monté de la configuration.
   \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{La phase d'instanciation}
  \begin{itemize}
   \item Lancer la commande "instance <fichier>.eol" ;
   \item renseigner les mots de passe ;
   \item enregistrement de la base matériel ;
   \item mise à jour ;
   \item éventuellement redémarrage.
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les mots de passe}
  \begin{itemize}
   \item Au premier lancement de l'instanciation, il est nécessaire de modifier les mots de passe :
   \begin{itemize}
    \item root ;
    \item l'utilisateur local à droit restreint (scribe, horus, amonecole, ...) ;
    \item sur amon, en cas d'utilisation d'un réseau pédagogique et au réseau administratif, un second administrateur (amon2) permet d'administrer le réseau pédagogique ;
    \item admin sur Scribe et Horus ;
    \item admin\_zephir sur Zéphir.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les mots de passe}
  \begin{itemize}
   \item Par défaut, le système regarde la pertinence des mots de passe. Pour cela, il utilise un système de "classe de caractères" :
   \begin{itemize}
    \item les lettres en minuscule,
    \item les lettres en majuscule,
    \item les chiffres,
    \item les  caractères spéciaux (Ex : \$*ù\%£, ; : !§/. ?) ;
   \end{itemize}
   \item il faut utiliser différentes classes de caractères ;
   \item par défaut, voici les restrictions :
   \begin{itemize}
    \item une seule classe de caractères : impossible,
    \item deux classes de caractères : 9 caractères,
    \item trois et quatre classes : 8 caractères ;
   \end{itemize}
   \item cette configuration est, bien évidement, modifiable dans gen\_config en mode expert.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : utilisation de VirtualBox pour EOLE}
 \begin{itemize}
  \item Activer PAE/NX dans Préférences/Système/Processeur ;
  \item choisir "Accès par pont" dans le "Mode d'accès réseau" dans Préférence/Réseau/Carte 1 ;
  \item créer un instantané.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : configuration autonome de Zephir1}
 \begin{itemize}
  \item Lancer gen\_config ;
  \item informations utiles :
  \begin{itemize}
   \item Adresse ip de la carte eth0,
   \item passerelle,
   \item DNS : DNS de la machine hôte.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : gen\_config en mode texte}
 \begin{itemize}
  \item taper gen\_config txt ;
  \item avoir l'aide help ;
  \item open zephir.eol ;
  \item choosegroup ;
  \begin{itemize}
   \item 0,
   \item niveau de mise à jour : passer en "complete" ;
  \end{itemize}
  \item save
  \item entrer le nom zephir.eol
  \item exit
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : intanciation de Zephir1}
 \begin{itemize}
  \item instance zephir.eol ;
  \item répondre aux questions :
  \begin{itemize}
   \item le mot de passe de l'utilisateur zephir ;
   \item le mot de passe root ;
   \item le mot de passe de l'utilisateur de l'application Zéphir admin\_zephir ;
   \item ne pas créer d'autres utilisateurs ;
   \item ne pas enregistrer le matériel ;
   \item ne pas mettre à jour.
  \end{itemize}
 \end{itemize}
\end{frame}

\section{L'application Zéphir}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Gestion des utilisateurs}
  \begin{itemize}
   \item Utilisation d'un serveur LDAP local ou distant
   \item LDAP local : scripts (/usr/share/zephir/utils) :
   \begin{itemize}
    \item add\_user.py
    \item del\_user.py
    \item list\_users.py
   \end{itemize}
   \item Un utilisateur = des affectations
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les modules, les établissements et les serveurs}
  \begin{itemize}
   \item Module : distribution spécifique + variantes
   \item Etablissement scolaire : lieu physique
   \item Serveur : un module dans un établissement
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Enregistrement Zéphir}
  \begin{itemize}
   \item Processus obligatoire et manuel
   \item Création dans la base + lien sécurisé
   \item Lancer : enregistrement\_zephir
   \begin{itemize}
    \item Connexion au réseau
    \item Connexion à Zéphir
    \item Création ou choix du serveur
    \item Gestion des configurations :
    \begin{itemize}
     \item nouveau serveur : "récupérer les fichiers de la variante" ;
     \item serveur configuré en mode autonome : "sauver la configuration actuelle" ;
     \item serveur configuré en mode Zéphir : "utiliser la configuration définie sur Zéphir".
    \end{itemize}
   \end{itemize}
   \item Sauvegarde de Zéphir : sauvegarde.sh
  \end{itemize}
\end{frame}

%%\begin{frame}
%% \frametitle{Configuration Zéphir de Scribe1}
%% \begin{itemize}
%%  \item Création d'un nouvel utilisateur ;
%%  \item affecter tous les droits à l'utilisateur ;
%%  \item se reconnecter avec ce nouvel utilisateur ;
%%  \item ajouter un nouvel établissement ;
%%  \item ajouter un serveur :
%%   \begin{itemize}
%%    \item le module : scribe-2.2 ;
%%    \item descriptif : Scribe1 ;
%%    \item configurer : état actuel/générer ;
%%    \item "Sauver sur Zéphir"
%%   \end{itemize}
%%  \item enregistrement Zéphir ;
%%  \item instanciation du serveur (ne pas remonter la configuration et ne pas faire la mise à jour).
%% \end{itemize}
%%\end{frame}

\begin{frame}
 \frametitle{Pratique : enregistrement Zéphir de Scribe1}
 \begin{itemize}
  \item Configuration de Zephir1 :
  \begin{itemize}
   \item création d'un nouvel utilisateur ;
   \item affecter tous les droits à l'utilisateur ;
   \item se reconnecter avec ce nouvel utilisateur ;
   \item ajouter un nouvel établissement ;
  \end{itemize}
  \item lancer gen\_config sur Scribe1 et configurer ;
  \item enregistrement Zéphir sur Scribe1 ;
  \item instanciation du serveur (ne pas remonter la configuration et ne pas faire la mise à jour).
 \end{itemize}
\end{frame}

\section{Administration}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{La phase d'administration}
 \begin{itemize}
  \item Correspond à l'exploitation du serveur ;
  \item Chaque module possède des fonctionnalités propres, souvent complémentaires.
  \item Diverses interfaces permettent la mise en œuvre de ces fonctionnalités et en facilitent l'usage :
  \begin{itemize}
   \item l'interface d'administration EOLE : EAD ;
   \item l'interface semi-graphique ;
   \item divers interface d'administration (Zéphir-web, CUPS, Sympa, ...) ;
   \item différents outils (Era, ...).
  \end{itemize}
  \item Gestion des mises à jour.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les mises à jour}
 \begin{itemize}
  \item Les différents dépôts :
  \begin{itemize}
   \item la version stable,
   \item la version candidate,
   \item la version dev ;
  \end{itemize}
  \item procédure :
  \begin{itemize}
   \item par l'EAD,
   \item par l'interface semi-graphique,
   \item par Zéphir,
   \item à la ligne de commande :
   \begin{itemize}
    \item Query-Auto : liste les mises à jour,
    \item Maj-Auto : lance la mise à jour sans question,
    \item Maj-CD : mise à jour grâce à un CD,
    \item Upgrade-Auto : mise à jour version une version supérieur,
   \end{itemize}
   \item mise à jour automatique : de 01h à 6h un jour par semaine.
  \end{itemize}
 \end{itemize}
\end{frame}


\begin{frame}
 \frametitle{Diagnostic}
  \begin{itemize}
   \item La commande "diagnose" permet de tester différent point du serveur ;
   \item La commande "diagnose -L" propose un diagnostic étendu.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Instance ou Reconfigure}
  \begin{itemize}
   \item L'instance doit être lancé qu'une seule fois sur les modules ;
   \item En cas de mise à jour, d'installation de paquet ou de changement de paramétrage : reconfigure.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : diagnostic}
  \begin{itemize}
   \item Lancer un diagnostic et un diagnostic étendu sur les serveurs.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : mise à jour}
  \begin{itemize}
   \item Mettre à jour le serveur Scribe1 et Zephir1 ;
   \item faire un reconfigure ;
   \item mettre à jour en candidat le serveur Scribe1.
   \item faire un reconfigure.
 \end{itemize}
\end{frame}

\section{Découverte de GNU/Linux}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Filesystem Hierarchy Standard (FHS)}
 \begin{itemize}
  \item / racine de l'arborescence sur laquelle sont raccrochés tous les sous-répertoires et fichiers.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Filesystem Hierarchy Standard (FHS)}
 \begin{itemize}
  \item (s)bin/ : commandes liées au système ;
  \item boot/ : noyau et initrd nécessaires au démarrage ;
  \item dev/ : fichiers spéciaux effectuant le lien noyau / périphérique ;
  \item etc/ : fichiers de configuration ;
  \item home|root/ : répertoires de connexion ;
  \item lib/ : librairies essentielles au démarrage et modules du noyau ;
  \item mnt/ : contient les montages des périphériques ;
  \item proc|sys/ : pseudo système de fichier représentant le noyau à un instant T|les processus ;
  \item tmp/ : répertoire temporaire accessible à tous ;
  \item usr/ : commandes utilisées par les utilisateurs (bin), l'administrateur (sbin), mais aussi ensemble du système graphique ;
  \item var/ : ensemble des données variables du système (spools, logs, web, base de donnée, ...).
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Adresse absolue / adresse relative}
 \begin{itemize}
  \item Un fichier ou un répertoire peut être défini :
  \begin{itemize}
   \item soit par un chemin relatif à l'endroit où vous vous positionnez au moment T.
   \item soit par un chemin absolu à partir de la racine de l'arborescence.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les différents types de fichier}
 \begin{itemize}
  \item - : fichier classique
  \item d : répertoire
  \item l : lien symbolique
  \item c : périphérique de type caractère
  \item b : périphérique de type bloc
  \item p : pile fifo
  \item s : socket
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les droits unix}
 \begin{itemize}
  \item Les droits standards :
  \begin{itemize}
   \item r : lecture
   \item w : écriture
   \item x : exécution
  \end{itemize}
  \item Autres droits :
  \begin{itemize}
   \item t/T : sticky bit : il interdit la suppression des fichiers qu'il contient à tout utilisateur autre que le propriétaire
   \item s/S : setuid et setgid bits : permet d'exécuté avec les droits du propriétaire ou du groupe
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Description d'un fichier}
 \begin{semiverbatim}
ls -li formation.pdf 
 \end{semiverbatim}
 \begin{semiverbatim}
3794089 -rw-r--r-- 1 emmanuel eole 252151 2009-11-13 09:56 formation.pdf
 \end{semiverbatim}
 \begin{itemize}
  \item inode
  \item droit
  \item compteur de lien physique
  \item propriétaire
  \item groupe
  \item taille
  \item date de dernière modification
  \item nom du fichier
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les ACLs}
 \begin{itemize}
  \item Les ACLs s'ajoutent aux droits standards ;
  \item possibilité de droit par défaut.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{La gestion des processus}
 \begin{itemize}
  \item Tous processus à :
  \begin{itemize}
   \item un PID ;
   \item un PPID ;
   \item un UID ;
   \item un état : Actif, Exécutable, Endormi, Zombi.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Quelques commandes}
 \begin{itemize}
  \item se déplacer : pwd, cd ;
  \item lister : ls, getfacl ;
  \item créer/supprimer un répertoire : mkdir, rmdir ;
  \item copier/renommer/déplacer : cp, mv ;
  \item lien : ln ;
  \item les droits : chmod, chown, chgrp, setfacl ;
  \item processus actif : ps, top ;
  \item tuer un processus : kill ;
  \item changer le mot de passe : passwd <user> ;
  \item lire le manuel : man <nom de la commande>.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : quelques commandes}
 \begin{itemize}
  \item sur Scribe1, se logguer en root ;
  \item changer le mot de passe de l'utilisateur scribe ;
  \item créer le répertoire /home/test ;
  \item renommer le en /home/eole ;
  \item mettre les droits de rwx pour l'utilisateur et le groupe mais --- pour autre ;
  \item vérifier les droits ;
  \item lire le man de setfacl ;
  \item ajouter la "lecture" de type ACLs pour le groupe "scribe" ;
  \item lister les droits ;
  \item lister la liste des processus ;
  \item tuer le processus "proftpd".
 \end{itemize}
\end{frame}

\section{Lire/éditer des fichiers}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Lire un fichier}
 \begin{itemize}
  \item Lire un fichier complet : less, cat ;
  \item lire le début d'un fichier : head ;
  \item lire la fin d'un fichier : tail (avec option -f) ;
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Editer un fichier : vim}
 \begin{itemize}
  \item Les modes :
  \begin{itemize}
   \item le mode normal : Esc ;
   \item le mode insertion : i ;
   \item le mode visuel : v.
  \end{itemize}
  \item Les fichiers :
  \begin{itemize}
   \item :e fichier.txt : editer le fichier ;
   \item :w : ecrire dans le fichier ;
   \item :q : quitter le fichier.
  \end{itemize}
  \item Autre :
  \begin{itemize}
   \item annuler, refaire : u; ctrl r ;
   \item couper, copier, coller : d, y, p ;
   \item caractère, mot, ligne : l, w, 1.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item lire la fin du fichier /var/log/syslog ;
  \item lire le début du fichier /var/log/messages ;
  \begin{itemize}
   \item passage de mode à un autre ;
   \item taper un peu de texte ;
   \item faire des couper/copier/coller ;
   \item annuler/refaire.
  \end{itemize}
 \end{itemize}
\end{frame}

\section{Les commandes à distances}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Le protocole ssh}
 \begin{itemize}
  \item protocole de communication sécurisé ;
  \item ouvrir une connexion : ssh utilisateur@ip\_serveur ;
  \item ouvrir une connexion pour commande graphique : ssh -X utilisateur@ip\_serveur ;
  \item transfert de fichier : scp fichier.txt utilisateur@ip\_serveur:.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Screen}
 \begin{itemize}
  \item si la connexion se coupe, impossible de récupérer la session ;
  \item screen permet de détacher un shell et le récupérer ;
  \item pour le lancer : screen ;
  \item pour détacher : ctrl a d ;
  \item attention déconnexion automatique : unset TMOUT ;
  \item pour reprendre un screen : screen -rd
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique : connexion ssh}
 \begin{itemize}
  \item Se connecter sur le serveur Scribe1 en ssh ;
  \item copier un fichier ;
  \item lancer gen\_config à travers ssh ;
  \item utiliser screen.
 \end{itemize}
\end{frame}

\section{Résolution des problèmes}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Trouver de l'information sur le serveur}
 \begin{itemize}
  \item Lecture des journaux d'activité :
  \begin{itemize}
   \item /var/log/messages : contient tous les messages d'ordre général concernant la plupart des services et démons ;
   \item /var/log/syslog : est plus complet que /var/log/messages, il contient tous les messages, hormis les connexions des utilisateurs ;
   \item /var/log/auth : contient les connexions des utilisateurs ;
   \item /var/log/mail.log : contient les envois et réception de mails ;
   \item /var/log/cron : fichier log du service cron (planificateur système).
  \end{itemize}
 \item diagnose ;
 \item gen\_rpt.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Trouver des informations sur Internet}
 \begin{itemize}
  \item la documentation ;
  \item les FAQ ;
  \item les archives des listes de diffusion ;
  \item le Wiki EOLE ;
  \item recherche sur Internet ;
  \item équipes d'assistance académiques.
 \end{itemize}
\end{frame}

\section{L'application Zéphir 2}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Préférence des utilisateurs}
 \begin{itemize}
  \item Contient les informations sur l'utilisateur (nom, prénom et mail) ;
  \item activer les alertes par mail ;
  \item envoyer un clef ssh.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Configurer l'utilisateur "eole" ;
  \item créé une clef ssh :
  \begin{itemize}
   \item ssh-keygen -t rsa
   \item récupérer le fichier /.ssh/id\_rsa.pub
  \end{itemize}
  \item ajouter la clef à l'utilisateur.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Surveillance des serveurs}
  \begin{itemize}
   \item Sur la page d'accueil ;
   \item sur chaque serveur : page Etat ;
   \item surveillance des serveurs ;
   \item état d'un groupe de serveur.
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les alertes}
 \begin{itemize}
  \item Envoi d'un mail en cas de détection d'un problème :
  \begin{itemize}
   \item remontée par le serveur d'un erreur ;
   \item un serveur n'a pas contacté Zéphir ;
   \item une opération s'est mal déroulée
  \end{itemize}
  \item A la selection d'un groupe enregistré : cocher "surveiller ce groupe"
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Actions}
  \begin{itemize}
   \item Zéphir agit à distance par des actions
   \item Elles sont mises en file d'attente
   \item C'est le serveur qui se connecte au Zéphir
   \item Exemple d'action : envoi de la configuration, mise à jour, sauvegarde l'état
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Lancer l'action de remonté de la configuration ;
  \item forcer la synchronisation : synchro\_zephir ;
  \item restaurer Scribe1.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Groupe de serveurs}
 \begin{itemize}
  \item Les variantes ne servent qu'à la configuration initial ;
  \item changement sur plusieurs serveurs : groupe de serveurs ;
  \item sélectionner les serveurs suivants différents critères ;
  \item sauvegarde du groupe ;
  \item possibilité d'ajout ultérieur de machine ;
  \item actions supplémentaires.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Créer un groupe de serveur ;
  \item autoriser l'utilisation à se connecté par clef SSH.
 \end{itemize}
\end{frame}

\section{L'interface d'administration semi-graphique}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{L'interface semi-graphique}
 \begin{itemize}
  \item L'interface semi-graphique est disponible sur différent module ;
  \item permet d'exécuter quelques tâches simple d'administration du serveur.
 \end{itemize}
\end{frame}

\section{L'interface d'administration EAD}
\begin{frame}{Plan}
  \begin{columns}[t]
  \begin{column}{5cm}
  \tableofcontents[sections={1-6},currentsection, hideothersubsections]
  \end{column}
  \begin{column}{5cm}
  \tableofcontents[sections={7-11},currentsection,hideothersubsections]
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}
 \frametitle{Présentation général}
 \begin{itemize}
  \item serveur de commande ead-server (activé et non désactivable) :
  \item interface ead-web : https://<adresse\_module>:4200/ (activé et désactivable) :
  \begin{itemize}
   \item gondole d'administration,
   \item menu action,
   \item les onglets,
   \item la partie centrale.
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Se connecter}
 \begin{itemize}
  \item Ajouter ou supprimer des onglets pour communiquer avec d'autres serveurs de commande ;
  \item authentification locale ;
  \item authentification SSO.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Fonction de base}
 \begin{itemize}
  \item Redémarrer, arrêter et reconfigurer ;
  \item mise à jour ;
  \item arrêt et redémarrage de service :
  \begin{itemize}
   \item mode expert,
   \item mode normal ;
  \end{itemize}
  \item listing matériel ;
  \item bande passante.
 \end{itemize}
\end{frame}
  
\begin{frame}
 \frametitle{Gestion des rôles}
 \begin{itemize}
  \item Rôle par défaut (administrateur sur tous les modules, professeur/eleve/administrateur de classe sur Scribe, administrateur du réseau pédagogique sur Amon) ;
  \item création de rôle personnalisé ;
  \item association de rôle :
  \begin{itemize}
   \item pour l'authentification locale : sur le login,
   \item pour l'authentification SSO :
   \begin{itemize}
    \item groupe d'utilisateur ;
    \item valeur de la clef typeadmin (professeur principal) ;
    \item login de l'utilisateur.
   \end{itemize}
  \end{itemize}
 \end{itemize}
\end{frame}

\section{Personnalisation du serveur à l'aide de Creole}
\begin{frame}{Plan}
  \small \tableofcontents[currentsection, hideothersubsections]
\end{frame}

\begin{frame}
 \frametitle{Création de patch}
 \begin{itemize}
  \item Génération normal : /etc/eole/distrib => /etc
  \item Génération avec patch : /etc/eole/distrib + /etc/eole/patch => /etc/eole/templates => /etc
  \item Créer un patch :
  \begin{itemize}
   \item copie du fichier original /etc/eole/distrib => /etc/eole/modif ;
   \item modification du fichier dans /etc/eole/modif ;
   \item exécution "gen\_patch" ;
   \item reconfiguration.
  \end{itemize}
  \item Désactiver un patch : supprimer le fichier dans /etc/eole/patch.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
  \begin{itemize}
   \item ClamAV à le paramètre suivant : LogFileMaxSize 2M ;
   \item il faut la valeur 10M.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Ajout de dictionnaires locaux}
  \begin{itemize}
   \item Permet d'ajouter des spécificités ou de nouveau template ;
   \item les dictionnaires locaux sont dans /etc/eole/dicos/local/ ;
   \item les templates locaux sont dans /etc/eole/distrib/ ;
   \item un dictionnaire est un fichier XML Creole ;
   \item un template utilise le langage de template Creole.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Syntaxe XML Creole}
 \begin{itemize}
  \item Entête XML : <?xml version="1.0" encoding="utf-8"?> ;
  \item Première balise <creole></creole>
  \begin{itemize}
   \item Inclusion de fichiers templates : <files><file name="..." .../></files> :
   \begin{itemize}
    \item name (obligatoire) : nom du fichier template ;
    \item source : si le nom de fichier source est différent de la destination ;
    \item mode, owner, group : droits sur fichier appliquer au fichier ;
    \item mkdir : création du répertoire de destination si nécessaire.
   \end{itemize}
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Syntaxe XML Creole : les variables}
 \begin{itemize}
  \item Ensemble de famille et séparateur : <variables></variables> ;
  \begin{itemize}
   \item Famille de variables : <family name='' [mode=''] [hidden='']></family> :
   \begin{itemize}
    \item Les variables <variable name='' type='' description='' [multi='True'] [hidden='True']/> :
    \item Les variables <variable name='' type='' description='' [multi='True'] [hidden='True']><value> ... </value></variable> :
   \end{itemize}
   \item Les séparateurs <separator></separator> :
   \begin{itemize}
    \item name : nom de variable en dessous du séparateur ;
    \item description affiché à l'intérieur de la balise.
   \end{itemize}
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Syntaxe XML Creole : les contraintes}
 \begin{itemize}
  \item Le contraintes : <constraints></constraints> : pour tester/remplir/grouper/conditionner des variables ;
  \begin{itemize}
   \item calcul automatique avec fonction personnalisé : <fill><param></param>...</fill> ;
   \item calcul automatique non modifiable <auto></auto> ;
   \item choix de réponse <check name='valid\_enum' target='var'><param>...</param></check> ;
   \item cacher des variables suivant des contraintes <condition name='hidden\_if\_in|hidden\_if\_not\_in' source='var'>...</condition> :
   \begin{itemize}
    \item valeur de la variable testé : <param>...</param> ;
    \item affecte <target type='family|filelist'>nom</target> :
   \end{itemize}
   \item Lien entre variable : <group master='var'>...</group> :
   \begin{itemize}
    \item si le maître à une valeur, les autres aussi ;
    \item si le maître est multi-évalué, les autres aussi ;
    \item les esclaves : <slave></slave>.
   \end{itemize}
  \end{itemize}
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Syntaxe XML Creole : l'aide}
  \begin{itemize}
   \item Afficher de l'aide dans l'interface : <help></help>.
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Installer le paquet ircd-irc2 ;
  \item créer un dicos pour générer le fichier /etc/sysconfig/eole/services/4\_ircd.srv ;
  \item dans la famille "services" ajouter la variable "activate\_ircd" ayant pour valeur possible "oui" et "non" ;
  \item tester gen\_config.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Langague de template Creole}
  \begin{itemize}
   \item Variable Creole préfixé par \begin{semiverbatim}\%\%\end{semiverbatim}
   \item Test : \begin{semiverbatim}\%if EXPRESSION   code if   \%else   code else   \%end if\end{semiverbatim}
   \item Test existance : \begin{semiverbatim}\%if \%\%is\_defined('variable')    code if   \%end if\end{semiverbatim}
   \item Boucle : \begin{semiverbatim}\%for \%\%i in EXPRESSION    hello \%\%i  \%end for\end{semiverbatim}
   \item Boucle pour variable multi évolué avec esclave : \begin{semiverbatim}\%for \%\%var in \%\%variablemaitre\end{semiverbatim}\begin{semiverbatim}\%\%var, \%\%var.esclave1, \%\%var.esclave2\end{semiverbatim}\begin{semiverbatim}\%end if\end{semiverbatim}
  \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Les services Creole}
 \begin{itemize}
  \item les services non-gérés : les services non référencés dans le système de gestion des services ;
  \item les services désactivés : retiré du démarrage et arrêté à l'instance/reconfigure : /etc/sysconfig/eole/disabled.srv ;
  \item les services activés : mis au démarrage et redémarré à l'instance/reconfigure : /etc/sysconfig/eole/services/*.srv.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique 1}
 \begin{itemize}
  \item Faire le template /etc/sysconfig/eole/services/4\_ircd.srv ;
  \item tester les différentes valeurs et faire reconfigure.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique 2}
 \begin{itemize}
  \item Installer phpldapadmin ;
  \item créer un dicos pour demander l'activation ou non (variable "activate\_phpldapadmin") ;
  \item si oui, activer une nouvelle famille "phpldapadmin" ;
  \item demander l'adresse IP (phpldapadmin\_host) et le nom du serveur (phpldapadmin\_name) ;
  \item copier les templates /etc/phpldapadmin/config.php et /etc/phpldapadmin/apache.conf dans /etc/eole/distrib/ ;
  \item le template config.php sera renommé en phpldapadmin.php ;
  \item si le nom n'est pas spécifié, le serveur : "Serveur LDAP" ;
  \item supprimer la configuration du TLS dans phpldapadmin ;
  \item tester sans reconfigurer : /usr/share/creole/creolecat.py -i /etc/eole/config.eol -o config.php /etc/eole/distrib/phpldapadmin.php
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique 3}
 \begin{itemize}
  \item Ajouter la possibilité d'activer ou non le TLS ;
  \item possibilité d'ajouter plusieurs serveurs.
 \end{itemize}
\end{frame}

\section{Zéphir}
\begin{frame}{Plan}
  \small \tableofcontents[currentsection, hideothersubsections]
\end{frame}

\begin{frame}
 \frametitle{Personnalisation d'un serveur}
  \begin{itemize}
   \item Liste des fichiers sauvegardés :
   \begin{itemize}
    \item dictionnaires additionnels
    \item fichier appartenant aux dictionnaires additionnels
    \item fichier spécifique (exemple généré par EAD)
    \item les patches
    \item les paquets additionnels
    \end{itemize}
   \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Ajouter les fichiers personnalisés dans l'application Zéphir pour Scribe2 ;
  \item ajouter la dépendance pour les paquets ;
  \item envoyer la configuration.
 \end{itemize}
\end{frame}


\begin{frame}
 \frametitle{Les variantes}
 \begin{itemize}
  \item Variante : configuration identique applicable à plusieurs serveurs
  \item Par défaut chaque module est dans la variante "standard"
  \item Création des templates, patchs et dicos éventuels
  \item Déplacement dans /etc/eole/patch/variante et /etc/eole/dicos/variante
  \item Fichiers ou paquets pas référencés : /usr/share/zephir/zephir\_conf/fichiers\_variante
  \item Dans /usr/share/zephir/scripts : ./creation\_variante
  \item Mettre à jour une variante : ./maj\_variante
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Créer une variante ;
  \item mettre Scribe2 dans la variante ;
  \item enregistrer Scribe2 dans Zéphir.
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Exécuter un script sur le client}
 \begin{itemize}
  \item Exécution sur un serveur ou un groupe de serveurs ;
  \item les scripts doivent être dans /usr/share/zephir/scripts/ ;
  \item ils doivent avoir l'extension .zephir ;
  \item ne pas spécifier l'extension lors de l'exécuxion ;
  \item fonctionseole.init\_proc : permet de vérifier si l'action est bloqué ;
  \item fonctionseole.zephir(<etat>, <message>, <type>) : log envoyer au Zéphir ;
  \item les scripts sont lancés en tant que uucp, si besoin utiliser sudo\_script('monscript.zephir').
 \end{itemize}
\end{frame}

\begin{frame}
 \frametitle{Pratique}
 \begin{itemize}
  \item Créer un script personnalisé permettant un supprimer un fichier dont le nom est en paramètre.
 \end{itemize}
\end{frame}

\end{document}