Tout apprendre sur le cloud computing ou l'informatique dans les nuages

Vous aurez besoin de services cloud si vous souhaitez avoir un accès permanent à vos services depuis n'importe où, ou si vous souhaitez avoir une sauvegarde sur Internet permanente.

Pour accéder par exemple à un serveur de fichiers dans une entreprise, il n'est pas forcément nécessaire d'utiliser une solution cloud, un VPN permettant d'entrer sur le réseau interne de l'entreprise pouvant suffire. Une solution cloud sera justifiée si vous souhaitez dématérialiser vos serveurs internes.

Vous trouverez ci-dessus une définition des termes qui reviendront régulièrement dans ce tutoriel.

• Datacenter : un datacenter ou centre de données est un lieu où vont être regroupés des serveurs installés dans des baies informatiques. À cela viendra s'ajouter une infrastructure réseau, un système de climatisation adapté, des systèmes anti-incendies, anti-intrusions, une alimentation électrique redondante et sécurisée par groupe électrogène. Vous y louerez soit des serveurs soit un emplacement (un quart, un tiers de baie) pour y placer vos équipements et vous permettant de bénéficier de l'infrastructure (réseau, électrique, climatisation).
• Virtualisation : en informatique, la virtualisation consiste en une abstraction des ressources. Une machine virtuelle contient un système d'exploitation exécuté sur un hôte nommé hyperviseur. Avec la virtualisation, il est par exemple possible d’exécuter un Windows virtualisé depuis un serveur Linux exécutant un hyperviseur. L'inverse est également possible, Hyper-V, hyperviseur de Microsoft peut exécuter des machines virtuelles Linux dans Windows.

• Hyperviseur : ordinateur ayant des capacités de virtualisation (support de la virtualisation par le CPU) et exécutant un logiciel de virtualisation nommé hyperviseur. (comme VMWare, KVM, VirtualBox). Il existe deux types d'hyperviseurs :

  • hyperviseur de type 1 ou bare metal : celui-ci ne va servir qu'à exécuter et gérer des machines virtuelles (VMWare ESX, KVM, Xen) ;
  • Hyperviseur de type 2 : un logiciel hyperviseur va s’exécuter sur un système d'exploitation. Le gestionnaire de machines virtuelles et les machines virtuelles peuvent être considérés comme des applications exécutées sur l'OS hôte (VirtualBox, VMWare Workstation).
• Conteneur : un conteneur consiste en la virtualisation d'une application ou d'un service. Plus léger qu'une machine virtuelle, un conteneur va utiliser le noyau du système d'exploitation qui l'accueille en cloisonnant les ressources. Docker est un système de gestion de conteneurs faisant référence.
• Network Attached Server (NAS) : il s'agit d'un serveur dédié au stockage, en général un boîtier contenant des disques accessibles sur le réseau via les protocoles classiques de partage de fichiers. Ceux-ci auront alors des fonctions plus ou moins avancées allant du simple partage de fichiers à des fonctions rivalisant avec un serveur d'entreprise.
• Storage Area Network (SAN) : il s'agit d'un réseau de stockage de données bas niveau. Les SAN fournissent des accès en mode blocs. Exemple, une baie de disque qui sera accessible à une ou plusieurs machines.
• Distributed File System (DFS) : il s'agit d'un système de fichiers réparti sur plusieurs machines. Le client (utilisateur ou matériel y accédant) n'a pas notion de cette répartition. Ce type de système est souvent associé à un mécanisme de redondance.
• Redondance : la redondance consiste à dupliquer les composants (matériels et/ou logiciels) de façon à garantir le fonctionnement d'un système en cas de défaillance d'un composant, ceci de façon transparente.

Les services cloud se présentent en plusieurs couches dont voici les principales.

• Infrastructure as a Service (infrastructure en tant que service, IaaS) : ce service est celui de plus bas niveau. Par exemple, il consiste en la mise à disposition de machines virtuelles, de conteneurs, de systèmes de fichiers distribués, de NAS/SAN. La partie « matérielle » (les différentes machines, l'infrastructure réseau et de répartition de charge) est sous la responsabilité du fournisseur de services.
• Platform as a Service (plateforme en tant que service, PaaS) : ce type de service fournit le système d'exploitation, le ou les moteurs de base de données et peut donner ou non la liberté d'installer des logiciels. Les logiciels peuvent aussi être préinstallés.
• Software as a service (logiciel en tant que service, SaaS) : à ce niveau, ce sont les applications qui sont proposées. On peut citer Microsoft Office 365 (pour la partie modification en ligne de documents, ou le logiciel installé sur votre poste), Google Docs, ou tout simplement un hébergement web.

D'autres couches peuvent être fournies telles que le Desktop as a Service (bureau virtuel en tant que service), le Storage as a Service (stockage en tant que service), la première étant haut niveau (SaaS), la seconde bas niveau (IaaS).

Les différentes briques IaaS, PaaS, SaaS peuvent être vues comme des briques mises en commun pour fournir la solution qui vous sera proposée ou que vous mettrez en place. Les différentes couches s’imbriquent comme des poupées russes et peuvent être comparées au modèle de couches OSI.

Avantages :

• gestion externalisée du matériel et de sa maintenance, facilité de montée en charge ;
• accessibilité depuis n'importe où ;
• synchronisation en temps réel ou différé en cas de rupture de liaison, par exemple des services tels que Dropbox ou Google Drive.

Inconvénients :

• captivité possible par rapport au produit utilisé et à Internet. En cas de coupure de liaison, aucune activité n’est possible ;
• la migration vers un autre fournisseur de services peut être compliquée. Cette contrainte a tendance à disparaître ;
• coûts d’utilisation pouvant être cachés ou difficiles à maîtriser, notamment si la facturation repose sur la bande passante ou l’espace utilisé, etc. ;
• exposition plus importante aux risques de piratage si tous les services d’une entreprise sont accessibles depuis Internet ;
• solution cadrée : vous n'aurez pas forcément accès à des réglages bien précis (c'est aussi un avantage pour la simplification de l'administration).

Cette liste est non exhaustive.

Le cloud privé consiste en un cloud dont les ressources vous sont dédiées. Il peut s'agir de votre propre matériel dans vos locaux, d’un matériel hébergé dans un centre de données dont vous louez une baie ou un équipement spécifique, ou d’un droit d’accès à l'infrastructure de votre hébergeur.

Dans le cloud public, vous utilisez des services mutualisés dans des fermes de serveurs. Évidemment, seules vos données vous sont accessibles et ne le sont qu'à vous, mais les ressources matérielles/système peuvent être partagées entre plusieurs clients. Vous formez votre infrastructure selon le cadre qui vous est fourni. Il s'agit d'un cloud managé.

Un cloud privé virtuel peut être déployé dans un cloud public.

Le cloud hybride, quant à lui, correspond à l'utilisation mixte d’un cloud public et d’un cloud privé. Par exemple, il peut s'agir de répartition de services entre plusieurs cloud, de redondance entre vos locaux et un centre de données, d'une partie de services externalisés communiquant avec des services internes par le biais de standards facilitant la communication.

OpenStack est un projet conjoint de la société Rackspace (acteur majeur des services cloud depuis des années) et de la NASA. L’intérêt principal d'OpenStack est de pouvoir fonctionner sur du matériel standard et hétérogène.

OpenStack est adapté aux infrastructures d'envergure, et est utilisé par OVH, le premier hébergeur européen pour son cloud public.

OpenStack est un ensemble de briques mises en commun pour utiliser une infrastructure cloud. Voici les briques principales :

Nova : gère les ressources de calcul (compute). C'est Nova qui va contrôler les hyperviseurs sur les machines physiques (et maintenant les gestionnaires de conteneurs comme Docker ou LXC) ;

Swift : c'est le système de stockage objet d'OpenStack (storage). Les données sont stockées sous forme d'objets (un fichier va être éclaté en plusieurs objets du point de vue bas niveau). Swift va gérer la redondance des données (réplication, répartition, autoréparation, ajout d'espace de stockage) ;

Cinder : Cinder est l'équivalent de Swift, mais en mode bloc (storage). Il va gérer l'attachement/détachement des périphériques virtuels, la gestion de snapshots ;

Neutron : c'est la brique qui va gérer le réseau : attribution d'IP, création de vswitch, etc. ;

Keystone : c'est le service qui va gérer les identités et autorisations ;

Glance : c'est le service de gestion d'images disque. Ce service va distribuer des images disque aux instances : modèles de disque, fichiers OVF.

Il s'agit là des briques les plus importantes.

OpenStack comporte des API pour communiquer avec les services EC2 et S3 d'Amazon.

Vous pouvez consulter ce tutoriel sur OpenStack. Ou vous rendre sur le site

site d'OpenStack.

VMWare est un acteur historique dans le monde de la virtualisation.

Oubliez les anciennes dénominations telles que ESX/ESXi au profit de VMWare vSphere.

La version vSphere gratuite se nomme VMWare vSphere Hypervisor, il s'agit en fait d'une version bridée de vSphere ne permettant l'utilisation que de la partie hyperviseur, suffisant dans le cadre de la gestion de trois ou quatre machines virtuelles, pour une petite structure.

Dans le cadre d'une utilisation payante, VMWare vSphere vCenter Server sera une machine virtuelle, installée sur un de vos hyperviseurs, qui gérera votre centre de données de façon globale. Vos hyperviseurs viendront s'intégrer dans une gestion centralisée. Certaines opérations ne seront alors faisables que depuis l'interface centralisée, d'autres pourront être effectuées depuis l'interface web de l'hyperviseur ou depuis l’interface web vCenter (les réglages seront alors visibles depuis l'une ou l'autre des interfaces). Vous pourrez facilement migrer à chaud une machine virtuelle d'un hyperviseur à un autre, et même d'un hyperviseur Intel vers un hyperviseur AMD (sous certaines conditions avec Enhanced vMotion Compatibility).

Dans VMWare vCenter Server, vous aurez une vision globale :

• des hyperviseurs ;
• des datastores ;
• des réseaux.

VMWare est utilisé en usage privé hors nuage, mais peut aussi servir de socle dans un ou des centres de données.

Dans le cadre d'une solution de cloud, le produit utilisé sera VMWare vCloud Suite, qui regroupe vSphere avec vRealize Suite, outil destiné à la modélisation et au provisionnement de projet.

Amazon propose une multitude de services de cloud computing, le plus connu étant S3 (Amazon Simple Storage Service). Dropbox utilisait auparavant S3. Amazon propose aussi une offre grand public, reposant sur S3, nommée Amazon Drive. Dans certains pays (mais pas la France), Amazon propose une offre gratuite et met à disposition 5 Go. Il existe aussi le service Amazon Prime Photo : un service Amazon Drive dédié aux photos.

Amazon fournit des briques de virtualisation, dont les plus connues sont :

• EC2 : Elastic Compute Cloud ;
• S3 : Simple Storage Service.

Vous pourrez gérer votre infrastructure depuis une interface web.

EC2 vous fournira des serveurs virtuels utilisant Xen, avec répartition de charge (load balancing).

S3 fournit un accès aux données en mode SOAP, REST, BitTorrent, mais peut aussi être utilisé par des API pour simuler un système de fichiers. Une machine virtuelle utilisera plutôt un stockage en mode bloc (EBS pour Amazon Elastic Bloc Store).

Vous pourrez migrer vos machines virtuelles vers Amazon à l'aide de AWS Server Migration Service.

Les services Microsoft Azure sont comparables aux services fournis par Amazon avec lesquels ils sont en concurrence. Vous pourrez intégrer bien évidemment facilement tous les produits Microsoft.

Azure Migrate vous permettra de facilement migrer vos machines virtuelles locales vers Azure.

Bien qu'Azure soit une technologie Microsoft, il est tout à fait possible d'y utiliser des machines virtuelles Linux. Scott Guthrie, vice-président exécutif cloud et IA chez Microsoft, déclarait en 2018 :  «  Près de la moitié des machines Azure sont sous Linux ».

Le service propose en plus de l'interface web « Azure (remote) PowerShell » qui permet d'effectuer les opérations en ligne de commande et de façon scriptée. Azure Migrate Server Assesment permet de migrer des machines virtuelles Hyper-V vers Azure.

Un tutoriel sur Microsoft Azure.

Oracle est à l'origine une entreprise spécialisée dans la base de données. Oracle a racheté Sun qui proposait VirtualBox, hyperviseur de type 2, gratuit.

Oracle est arrivé sur le tard dans le monde du cloud par rapport à AWS ou Azure. Leur interface va proposer globalement le même type de services que ses concurrents.

Tout comme Microsoft facilite l'intégration de ses différents produits dans son cloud, Oracle va faciliter l’intégration des siens dans son cloud, notamment ses produits de bases de données.

Il est possible depuis les versions 6 de VirtualBox d'uploader une machine virtuelle vers le cloud Oracle. Il faudra auparavant préparer celle-ci (voir la documentation), et l'upload devra se faire lorsque la machine virtuelle est arrêtée. Vous pourrez aussi importer une machine virtuelle du cloud, ou directement en créer une dans le cloud Oracle depuis VirtualBox. Il est également possible de télécharger une machine virtuelle du cloud Oracle dans VirtualBox.

Les services fournis par Google sur leur infrastructure Google Cloud Platform s'appuient sur la même infrastructure utilisée par G-Suite. Ils vous fourniront le même type de services que ses concurrents.

La grosse différence de Google étant la fourniture de l'infrastructure G-Suite sur leurs services.

Hadoop est un framework open source fourni par l’Apache Fundation. Ce framework est destiné au traitement de données de très gros volumes en facilitant la création d'applications distribuées. Il est utilisé dans les traitements big data.

Il se décompose en deux parties principales :

• HDFS : Hadoop Distributed File System : il s'agit du système de fichiers distribués stockant les données ;
• MapReduce : il s'agit du module de traitement de données proprement dit (composé de la fonction Map qui va effectuer la répartition du traitement et de Reduce qui réduira le résultat en une seule synthèse).

À cela peut être ajouté un module nommé Hbase, SGBD distribué non relationnel orienté colonnes.

Les principaux acteurs du cloud (Google, Amazon, OVH, etc.) sont en mesure d'offrir des instances Hadoop à leurs clients.

Hadoop n'est pas adapté à n'être utilisé qu'en système de fichiers.

Il faut voir le cloud comme un accès à de la ressource et non à du matériel. Bien qu'il soit possible d'avoir un cloud ou de monter un cloud avec votre propre matériel dans une baie d’un centre de données, ou même chez vous, il est beaucoup plus simple d'avoir de la ressource virtualisée.

Un système de fichiers virtualisé permettra plus facilement de mettre en place une politique de redondance, de tolérance de panne et l'augmentation d'espace. L'usage de disques en RAID matériel vous permettra de pallier une panne disque, mais ne vous permettra pas d'agrandir facilement un volume. LVM vous permettra de facilement ajouter de l'espace en ajoutant par exemple un disque à un volume logique, vous permettra de facilement remplacer un disque en déplaçant son contenu d'un disque à l'autre, de créer des snapshots, voire d'utiliser un SSD en cache d'un disque mécanique. L’utilisation d’un système de fichiers distribué, comme nous allons le voir, vous permettra de gérer cela à plus grande échelle : il sera possible de sortir une machine contenant x disques du système pour la remplacer, et cela automatiquement. Le système de fichiers distribué se chargera de la répartition/duplication des données.

Même sans parler de cloud, utiliser un hyperviseur vous permettra de limiter le nombre de serveurs physiques à gérer (il faudra bien entendu une machine correctement dimensionnée) et de plus facilement le remplacer en déplaçant, d'une machine à l'autre, les machines virtuelles à chaud. Vous pourrez mettre en place une réplication et gérer de la répartition de charge.

L'intérêt d'utiliser des ressources mises à votre disposition par un hébergeur plutôt que votre propre matériel vous décharge de la surveillance matérielle de celui-ci, et vous permet de facilement augmenter ou diminuer les ressources que vous utilisez. La mise à disposition d'une machine virtuelle se fait en quelques minutes, voire quelques secondes ; solution qui vous demanderait en interne beaucoup de ressources ne serait-ce que par la préparation de templates (en temps passé et en matériel), vous monopolisant de la ressource pour un usage pas forcément fréquent. Chez un hébergeur, ce type de template n'occupe pas forcément de ressources de votre point de vue et n’est pas facturé si vous utilisez des templates prédéfinis par votre hébergeur.

Un conteneur peut être vu comme un système de virtualisation léger, qui va servir à virtualiser une application ou un service (au sens démon Unix) plutôt qu'un OS complet. Contrairement à une machine virtuelle, un conteneur va partager le noyau de l'hôte. C'est un cloisonnement moins strict, mais demandant moins de ressources.

Les conteneurs prennent de plus en plus d'ampleur, et la plupart des fournisseurs de cloud fournissent du Container as a Service (CaaS).

Kubernetes est le système d'orchestration faisant référence et à la mode. Il est utilisé par la plupart des services cloud. Il vous permettra de déployer et de surveiller vos conteneurs.

Nos tests seront effectués depuis une distribution Debian 9 Stretch 64 bits. Au moment de la rédaction, Debian 10 Buster est la dernière version de la distribution, sortie le 6 juillet 2019. Celle-ci étant encore jeune, nous utilisons la version antérieure.

La compatibilité étant en général ascendante, le tutoriel pourra globalement s'appliquer aux versions système supérieures.

Les outils utilisés sont en général disponibles dans les autres distributions Linux.

Certaines commandes devront être adaptées comme remplacer :

/etc/init.d/mysql start

par :

service mysql start

ou :

systemctl mysql start

Network Information Service (NIS) est aussi connu sous le nom de Yellow Pages. Le service permet de distribuer les différents fichiers de configuration tels que /,etc/hosts /,etc/password sur différentes machines via le réseau. Ceci permet la recopie automatique des mots de passe et configurations entre différents hôtes. NIS est spécifique au monde Unix/Linux.

Dans notre exemple, nous fixerons le nom de notre première machine sur srv1.

Nous installons NIS :

apt-get install nis

il vous sera demandé le domaine NIS, nous utiliserons « cloudsrv ».

L'installation reste bloquée un moment sur :

Paramètrage de nis ...

mais finit par aboutir.

Avant toute chose, pour sécuriser le service, nous modifions le fichier /etc/ypserv.securenets et créons un fichier /var/yp/securenets, dans lequel nous n’autorisons que notre serveur et une seconde machine 192.168.1.200 qui sera utilisée dans les prochains tests :

host 127.0.0.1
host 192.168.1.200
host 192.168.1.201

Nous modifions ensuite le fichier /,etc/default/nis et remplaçons la ligne

NISSERVER=false

par :

NISSERVER=master

Nous redémarrons ensuite le serveur :

service nis restart

Nous initialisons ensuite la base de données :

/usr/lib/yp/ypinit -m

Vous devez ensuite entrer la liste des serveurs, terminée par Ctrl-D. Nous n'avons que le serveur local actuellement.

9-1-1. Ajout d'un client NIS▲

passwd:         compat nis
group:          compat nis
shadow:         compat nis

Pas de répertoire, connexion avec HOME=/

passwd : Erreur de manipulation du jeton d'authentification
mot de passe non changé.

cd /var/yp
make

make[1] : Entering directory '/var/yp/cloudsrv'
Updating passwd.byname...
Updating passwd.byuuid...
Updating netid.byname...
Updating shadow.byname... Ignored -> merged with passwd
make[1] : Leaving directory '/var/yp/cloudsrv'

9-1-2. Ajout d’un serveur secondaire▲

NISSERVER=

NISSERVER=slave

NISMASTER=

NISMASTER=srv1

9-1-3. Conclusion▲

Lightweight Directory Access Protocol (LDAP) est une référence dans les services d’annuaire. Celui-ci permet à la plupart des serveurs (au sens logiciel) d'avoir une base de données centralisée incluant les utilisateurs, éventuellement leurs coordonnées, des machines, des ressources, etc. Active Directory de Windows Server s'appuie sur LDAP, la plupart des serveurs SMB, serveurs mails, serveurs d'impression, copieurs, peuvent s'authentifier à travers LDAP. Il est possible de s'authentifier sous Linux via LDAP également (ce que nous allons voir).

Sur une base LDAP vient se greffer des schémas. Ceux-ci vont définir des objets et des attributs venant s'intégrer dans la base LDAP. Des démons vont fournir des schémas pour intégrer des objets ou attributs à la base LDAP qu'ils vont ensuite utiliser.

Il est possible d'importer et d'exporter des données depuis un annuaire LDAP via des fichiers .ldif (LDAP Data Interchange Format).

LDAP est à mon avis difficile à prendre en main. C'est par contre la solution pour centraliser une authentification depuis plusieurs briques logicielles différentes. Il est également possible d'avoir un serveur de réplication, ce qui est dans le cadre de ce tutoriel indispensable pour assurer la redondance.

Les termes les plus courants utilisés par LDAP sont :

• dc: Domain Component ;
• dn: Distinguished Name ;
• cn: Common Name ;
• ou: Organisational unit.

Et voici un schéma sur l'organisation :

  dc=FR
              |
          dc=EXEMPLE
         /          \
   ou=machines    ou=personnes
       /              \
cn=ordinateur       cn=Jean

Ceci aboutissant à deux Distinguished Names :

• cn=ordinateur,ou=machines,dc=EXEMPLE,dc=FR

• cn=Jean,ou=personnes,dc=EXEMPLE,dc=FR

9-2-1. Installation▲

Nous allons installer l’implémentation OpenLDAP via le paquet slapd (Stand-alone LDAP Daemon).

 

Sélectionnez

apt-get install slapd

Il vous sera demandé un mot de passe administrateur.

Nous configurons ensuite le service :

 

Sélectionnez

dpkg-reconfigure slapd

Le premier écran vous demande si vous voulez « omettre la configuration », il faut donc répondre « non » pour effectuer celle-ci :

Nous allons ensuite entrer le « nom de domaine » LDAP. Dans l'exemple je vais utiliser developpez.com.

Le second écran demande le nom de l'organisation, je saisis « developpez »

On vous demandera ensuite le mot de passe administrateur, ce qui est normal, car nous créons une nouvelle base. L'écran suivant demande le format de base de données à utiliser, nous laissons le choix proposé : MDB.

L'écran suivant demande s’il faut supprimer la base en cas de désinstallation de LDAP, et s’il faut déplacer l'ancienne base. Comme celle-ci est vide, nous pouvons répondre « non ».

9-2-2. Installation de LAM (LDAP Account Manager)▲

Pour éviter de devoir utiliser des lignes de commande intégrant des fichiers .ldif pour l'ajout d'utilisateurs, nous allons utiliser LAM (LDAP Account Manager) qui permet de piloter la base LDAP depuis un navigateur web.

Il est tout à fait possible de se passer de LAM et d'utiliser des fichiers .ldif et les commandes Shell. Ce tutoriel ciblera uniquement l'utilisation de LAM.

Pour installer LAM :

 

Sélectionnez

apt-get install ldap-account-manager

Avant d'aller plus loin, nous allons commencer par activer le support de HTTPS. Si vous avez ajouté LAM sur une machine possédant déjà Apache avec un certificat, vous pouvez modifier directement le fichier VirtualHost. Sinon il va vous falloir installer un certificat ou en créer un autosigné.

Pour la création d'un certificat autosigné :

 

Sélectionnez

openssl req -new -x509 -days 365 -nodes -out /ets/ssl/certs/lam.crt -keyout /etc/ssl/private/lam.key

Nous activons ensuite le module SSL d'Apache :

 

Sélectionnez

a2enmod ssl

Modification de la configuration de LAM :

il va falloir éditer le fichier /etc/apache2/conf-enabled/ldap-account-manager.conf.

Nous entourons le contenu avec une balise <Virtualhost> et ajoutons les éléments de configuration SSL :

 

Sélectionnez

<VirtualHost *:443>
SSLEngine on
SSLCertificateFile /etc/ssl/certs/lam.crt
SSLCertificateKeyFile /etc/ssl/private/lam.key

… contenu original

</VitualHost>

Nous redémarrons Apache :

 

Sélectionnez

service apache2 restart

À ce stade, vous pourrez appeler LAM avec http://[adresse ip/nom DNS]/lam ou https://[adresse ip/nom DNS]/lam.

Il restera à éventuellement modifier la configuration pour forcer le passage en HTTPS.

Lors de la connexion, vous aurez l'écran suivant :

En lançant l'interface web, j'ai eu des messages d'erreur indiquant l'absence de support du XML et de zip avec ma version de PHP. Pour régler ce souci, il faut installer les paquets php-xml et php-zip et redémarrer Apache.

Passons à la configuration de LAM. Nous cliquons sur « Configuration de LAM » en haut à droite :

Il va nous falloir aller dans « modifier les profils » :

Le mot de passe par défaut est « lam », la première chose à faire est de le changer :

Ceci va changer le mot de passe de l'édition de profil. Nous allons ensuite créer un nouveau profil :

Configuration de LAM → Modifier les profils → Gestion des profils serveur :

Nous ajoutons un nouveau profil :

Il vous faudra entrer le mot de passe principal renseigné auparavant :

Nous passerons directement sur l'écran de configuration du nouveau profil :

Il va nous falloir effectuer les réglages suivants :

• suffixe d'arborescence : remplacer dc=yourdomain,dc=org par dc=developpez,dc=com (le domaine que nous avions paramétré étant developpez.com) ;
• paramètre de langue : sélection du langage par défaut ainsi que du fuseau horaire ;
• paramètres de sécurité-->liste des utilisateurs valides : remplacer cn=Manager,dc=my-domain,dc=com par cn=admin,dc=developpez,dc=com. (admin est l'utilisateur administrateur par défaut sur un serveur LDAP) ;
• puis le mot de passe.

Avant de valider, il va falloir effectuer des modifications dans l'onglet type de compte :

Il faut modifier les champs dc= des suffixes LDAP, pour les utilisateurs, les groupes, les machines, et les domaines Samba. Nous n'utiliserons que les suffixes utilisateurs (ou=People) et groupe (ou=group), mais fixons correctement les entrées machines et Samba, en cas d'utilisation ultérieure. Nous mettons dc=developpez,dc=com.

Une fois tous ces éléments entrés, vous pourrez vous connecter :

Pensez à retourner dans le gestionnaire de profil afin de supprimer le profil lam.

Lors de la première connexion, vous verrez l'écran suivant :

Si les éléments sont corrects, cliquez sur « Créer ». Vous aurez le message « Modifications effectuées avec succès ».

Il va nous falloir créer un groupe, sans quoi nous ne pouvons pas créer d’utilisateurs :

Je crée un groupe nommé « users ».

Nous voyons que l'opération est réussie, mais ne voyons pas le groupe. Un clic sur Groupes rafraîchira la page et nous verrons le groupe.

Nous créons ensuite un utilisateur « test ».

Beaucoup de champs sont à notre disposition, nous n'utiliserons que le champ nom (champ obligatoire).

Nous allons permettre plus tard une authentification Unix depuis ce compte (pour nos tests), il va falloir cliquer sur le bouton « Unix » à gauche. Vous verrez que le champ répertoire utilisateur est positionné sur /home/$user, le chemin normal des comptes utilisateurs dans une arborescence Unix, $user étant bien entendu remplacé par le nom de l'utilisateur. Si vous ne souhaitez pas qu'un utilisateur puisse lancer un Shell, il faudra positionner le champ Shell de connexion sur false.

Il vous faudra ensuite cliquer sur le bouton définir le mot de passe pour positionner celui-ci.

Et ensuite, dernière étape, enregistrer le compte en cliquant sur le bouton Sauvegarder.

En cliquant sur Vue arborescente en haut, vous aurez comme le nom l’identique, une vue arborescente, mais vous pourrez également importer et exporter des fichiers .ldif, et exporter également aux formats csv et vcard.

9-2-3. Authentification Linux avec une base LDAP▲

PAM (Pluggable Authentication Modules) est l'API utilisée sous Linux permettant de déléguer l'authentification à plusieurs services différents (LDAP, NIS, bases de données au format Berkeley, etc.). Cette API nous permettra d'effectuer une authentification transparente avec un utilisateur de notre annuaire LDAP. Nous nous authentifierons avec un compte LDAP avec la simple commande login. nssswitch (Name Service Switch) va travailler en collaboration avec le service PAM pour se substituer ou modifier les fichiers de configuration password, shadow, hosts, aliases.

Nous aurons besoin pour cela du paquet libnss-ldapd et ses dépendances :

 

Sélectionnez

apt-get install libnss-ldapd

Le premier écran demandera l'adresse du serveur LDAP, nous remplaçons l'URL ldapi:// par ldap://127.0.0.1 pour une utilisation locale, et l'adresse IP du serveur depuis un poste client.

Sur le prochain écran, il faudra entrer le dn utilisé, soit : dc=developpez,dc=com :

Le paquet vous demande les services à activer, il faudra au minimum cocher password et shadow.

Une fois la configuration effectuée, vous pourrez vous loguer depuis la console avec le compte « test ».

Une fois logué, vous vous trouverez à la racine. Le dossier utilisateur n'a pas été créé. lam ne crée pas automatiquement celui-ci. Dans le cadre de notre tutoriel, cela est très bien. Si vous souhaitez gérer cela, consulter la documentation de lam.

Si vous changez le mot de passe avec la commande passwd, celui mettra bien à jour le compte ldap :

Une fois l'authentification LDAP activée, il ne sera toujours pas possible de s'authentifier avec le compte root local. LAM ne vous laissera pas créer un compte avec un UID inférieur à 10 000, empêchant la création d'un compte root dans LDAP.

Si vous souhaitez ajouter un compte, en cas d'utilisation de la commande adduser, vous pourrez constater que le compte est créé en local et non dans la base LDAP. Pour ajouter un utilisateur LDAP, il faut utiliser la commande lpadadd avec en paramètre un fichier ldif, d’où l’intérêt d'utiliser LAM pour simplifier l'opération.

La création d'un compte utilisateur LDAP ne déclenche pas la création du dossier de l'utilisateur. Ceci peut être fait en ajoutant la ligne suivante au fichier /etc/pam.d/common-session :

 

Sélectionnez

session     required      pam_mkhomedir.so skel=/,etc/skel umask=0022

9-2-4. Authentification Mac OS avec une base LDAP▲

9-2-5. Authentification Windows sur un serveur LDAP▲

9-2-6. Sauvegarde restauration LDAP▲

slapcat -b rootsuffix -l fichier.ldif

slapadd -c -b suffixroot -l fichier.ldif

9-2-7. Serveur secondaire LDAP▲

Kerberos est un protocole d'authentification basé sur un échange de clés secrètes et générant des tickets d'authentification. Il ne vous servira pas à vous connecter directement, mais permettra à des services comme LDAP de vous identifier. Une fois authentifié, un ticket a une durée de vie et peut être invalidé, une reconnexion sera alors nécessaire.

Kerberos est assez répandu. Il est utilisé par l'Active Directory de Microsoft et il peut être utilisé avec LDAP (notamment via l'implémentation Linux Heimdal).

Voici comment fonctionne l’authentification Kerberos :

Kerberos se décompose en deux parties :

• Authentication Service (AS) : qui délivrera un ticket de demande d'accès en cas d'authentification réussie ;
• Ticket Granting Service (TGS) : qui fournira un ticket d'accès au service demandé.

Précisément, l'utilisateur s'authentifie auprès de l'AS via un ticket généré par son client Kerberos (couple login, mot de passe hashé (pas de mot de passe en clair), horodatage), si l'authentification est correcte, il reçoit un ticket TGT (clé de session TGS) : comparable à un contrôle d'identité par un vigile qui va vous délivrer un badge. Ce ticket n'est pas déchiffrable par l'utilisateur.

L'utilisateur va ensuite demander un ticket d'accès au TGS via la clé de session qu'il a reçue. Un peu comme une carte magnétique qui vous sera donnée en plus du badge par un second vigile après avoir passé le premier contrôle, et vous donnera accès à un étage ou non, carte magnétique délivrée en plus du badge et valable pour le porteur du badge pendant un temps précis et pour des choses précises.

Kerberos ne sert qu'à faire la preuve de votre identité. Les services utilisant Kerberos (exemple serveur de fichiers) sauront que vous avez été authentifié et que votre authentification est valide jusqu'à une heure précise, mais les droits d'accès restent à leur charge (dans le cas d'un serveur de fichiers un utilisateur A a accès au dossier X, mais pas au dossier Y).

Une extension à Kerberos nommée PKINIT permet de remplacer l'authentification via un couple login/mot de passe par une carte à puce.

En environnement Windows, Active Directory va centraliser la gestion des ressources (serveurs, ordinateurs, utilisateurs, partages). Active Directory s'appuie sur une implémentation LDAP propriétaire et utilise Kerberos. Active Directory permet aussi le déploiement d'applications (ou de systèmes complets), de politiques de sécurité (pouvant être vues comme des réglages comme l'impossibilité d'accéder à la configuration système, à la ligne de commande, lancement d'une seule application sans accès au système notamment avec le bureau à distance, fond d'écran paramétré à distance, etc.). Une infrastructure AD part d'une racine nommée forêt, qui va contenir un ou plusieurs domaines (comme une arborescence DNS). Un domaine va contenir au minimum un serveur qui fera contrôleur de domaine. Si un seul serveur est présent dans l’infrastructure, il fera office de contrôleur de foret et contrôleur de domaine. Les objets d'un domaine sont répliqués entre les différents contrôleurs membres du domaine.

Mac OS Server intègre un système nommé OpenDirectory, fork d'OpenLDAP pour fournir son service centralisé d'authentification. OpenDirectory permet la connexion à un domaine Microsoft Active Directory.

Depuis Mac OS 10.8 Mountain Lion, Mac OS Server est une application à acheter sur l'Apple Store, qui devient une simple extension de Mac OS. Mac OS Server est depuis un moment en déclin notamment avec l'abandon des serveurs Apple Xserve. Mac OS High Sierra peut faire serveur Time Machine. La montée en puissance des NAS à prix abordable permettant l'utilisation de services proposés par Mac OS Server ne fait qu’accélérer son déclin.

NIS n'est pas réputé pour être très sécurisé. Il est envisageable de l'utiliser à travers un réseau sécurisé en VLAN en interne ou via un tunnel VPN entre plusieurs sites. Il est spécifique au monde Unix et est plus que déprécié. Cette solution ne sera pas utilisée dans un environnement cloud.

LDAP n'est pas simple à implémenter, mais à l’avantage d'être un standard très répandu.

Le principe de réplication va consister à garder une ou plusieurs copies des bases de données en les synchronisant entre plusieurs machines.

Cette réplication peut être de type :

• maitre-esclave ;
• maitre-maitre.

10-1-1. Maitre-esclave▲

10-1-2. Maitre-maitre▲

10-1-3. Détails▲

10-1-4. Activation de la réplication entre un maitre et un esclave▲

bind-addess    = 127.0.0.1

bind-addess    = 0.0.0.0

mysql -u root -p
Enter password :
Welcome to the MYSQL monitor. Commands end with ; or \g.
Your MySQL connection id is 94
Server version: 5.5.59-0+deb8u1-log (Debian)

Copyright ( c ) 2000, 2018, Oracle and/or its affiliates. All rights reserved.

Oracle is a registerd trademark of Oracle Corporation and/or its 
affiliates. Other names may be trademarks of their respective 
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

Myslq > GRANT REPLICATION SLAVE ON *.* TO ‘sync’@'192.168.1.201’ IDENTIFIED BY 'motdepasse';
Query OK, 0 rows affected (0.00 sec)

FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

FLUSH TABLES WITH READ LOCK;
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW MASTER STATUS;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000002 |    68145 |              |                  |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

mysqldump –all-databases -u root -p >export.sql
Enter password:
– Warning: Skipping the data of table mysql.event. Specify the –events option explicitly.

mysql > UNLOCK TABLES ;
Query OK, 0 rows affected (0.00 sec)

mysql -u root -p <export,sql
Enter password:

mysql> STOP slave;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> CHANGE MASTER TO MASTER_HOST='192.168.1.200',
    -> MASTER_USER='sync',
    -> MASTER_PASSWORD='motdepasse',
    -> MASTER_LOG_FILE='mysql-bin.000002',
    -> MASTER_LOG_POS=68145;
Query OK, 0 rows affected (0.10 sec)

mysql> START slave;
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW SLAVE STATUS \g
+----------------------------------+-------------+--------------+-------------+---------------+------------------+---------------------+-------------------------+---------------+-----------------------+------------------+-------------------+-----------------+---------------------+--------------------+------------------------+-------------------------+-----------------------------+------------+------------+--------------+---------------------+-----------------+-----------------+----------------+---------------+--------------------+--------------------+--------------------+-----------------+-------------------+----------------+-----------------------+-------------------------------+---------------+---------------+----------------+----------------+-----------------------------+------------------+
| Slave_IO_State                   | Master_Host | Master_User  | Master_Port | Connect_Retry | Master_Log_File  | Read_Master_Log_Pos | Relay_Log_File          | Relay_Log_Pos | Relay_Master_Log_File | Slave_IO_Running | Slave_SQL_Running | Replicate_Do_DB | Replicate_Ignore_DB | Replicate_Do_Table | Replicate_Ignore_Table | Replicate_Wild_Do_Table | Replicate_Wild_Ignore_Table | Last_Errno | Last_Error | Skip_Counter | Exec_Master_Log_Pos | Relay_Log_Space | Until_Condition | Until_Log_File | Until_Log_Pos | Master_SSL_Allowed | Master_SSL_CA_File | Master_SSL_CA_Path | Master_SSL_Cert | Master_SSL_Cipher | Master_SSL_Key | Seconds_Behind_Master | Master_SSL_Verify_Server_Cert | Last_IO_Errno | Last_IO_Error | Last_SQL_Errno | Last_SQL_Error | Replicate_Ignore_Server_Ids | Master_Server_Id |
+----------------------------------+-------------+--------------+-------------+---------------+------------------+---------------------+-------------------------+---------------+-----------------------+------------------+-------------------+-----------------+---------------------+--------------------+------------------------+-------------------------+-----------------------------+------------+------------+--------------+---------------------+-----------------+-----------------+----------------+---------------+--------------------+--------------------+--------------------+-----------------+-------------------+----------------+-----------------------+-------------------------------+---------------+---------------+----------------+----------------+-----------------------------+------------------+
| Waiting for master to send event | 192.168.8.1 | sync |        3306 |            60 | mysql-bin.000003 |               19312 | mysqld-relay-bin.000003 |         19458 | mysql-bin.000003      | Yes              | Yes               |                 |                     |                    |                        |                         |                             |          0 |            |            0 |               19312 |           36625 | None            |                |             0 | No                 |                    |                    |                 |                   |                |                     0 | No                            |             0 |               |              0 |                |                             |                1 |
+----------------------------------+-------------+--------------+-------------+---------------+------------------+---------------------+-------------------------+---------------+-----------------------+------------------+-------------------+-----------------+---------------------+--------------------+------------------------+-------------------------+-----------------------------+------------+------------+--------------+---------------------+-----------------+-----------------+----------------+---------------+--------------------+--------------------+--------------------+-----------------+-------------------+----------------+-----------------------+-------------------------------+---------------+---------------+----------------+----------------+-----------------------------+------------------+
1 row in set (0.00 sec)

10-1-5. Activation de la réplication maitre-maitre▲

mysql> GRANT REPLICATION SLAVE ON *.* TO 'sync'@'192.168.8.200' IDENTIFIED BY 'motdepasse';
Query OK, 0 rows affected (0.00 sec)

mysql> SHOW MASTER STATUS;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000001 |      265 |              |                  |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

mysql> STOP slave;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> CHANGE MASTER TO 
    -> MASTER_HOST='192.168.1.200',
    -> MASTER_USER='sync',
    -> MASTER_PASSWORD='motdepasse',
    -> MASTER_LOG_FILE='mysql-bin.000001',
    -> MASTER_LOG_POS=265;
Query OK, 0 rows affected (0.06 sec)

mysql> START slave;
Query OK, 0 rows affected (0.00 sec)

Le moteur Federated de MySQL Server permet de « voir » une table sur un serveur distant dans une base locale. Ceci n'a pas pour but d'apporter des fonctions de clustering, mais peut permettre par exemple la centralisation d'une table d'utilisateurs pour plusieurs serveurs.

Ce moteur comporte des contraintes :

• il faut démarrer MySql Server avec l'option –federated ;
• les transactions sont impossibles sur cette table ;
• pas de modification de la table en local, celle-ci doit impérativement être faite sur le serveur distant ;
• pas de cache de requêtes, les données proviennent de la base de données distante et ralentissent donc les lectures ;
• si le serveur distant est indisponible, la table FEDERATED l'est également.

Sa mise en place se fait comme suit :

Déclaration sur le serveur hébergeant la table :

CREATE TABLE test (
    id     int(20) NOT NULL auto_increment,
    nom   varchar(32) NOT NULL default '',
    PRIMARY KEY  (id),
    KEY name (name),
)
ENGINE=InnoDB;

Déclaration sur le serveur voulant utiliser la table distante :

CREATE TABLE test_distant (
    id     int(20) NOT NULL auto_increment,
    nom   varchar(32) NOT NULL default '',
    PRIMARY KEY  (id),
    KEY name (name),
)
ENGINE=FEDERATED
COMMENT='mysql://utilisateur@serveur:9306/federated/test';

Un cluster de bases de données est un système distribué dans une grappe de serveurs. Celle-ci va permettre la répartition de charge et la tolérance de panne. Le principe est similaire aux systèmes de fichiers distribués.

Pour mettre en place notre cluster de bases de données, nous utiliserons Galera Cluster.

Galera Cluster est un cluster libre pour MySQL. Il se compose de deux parties :

• de Galera ;
• d’une version de MySQL, fournie intégrant l'API WSREP.

10-3-1. Installation de Galera cluster avec MariaDB▲

[mysqld]
query_cache_size=0
binlog_format=ROW
default_storage_engine=innodb
innodb_autoinc_lock_mode=2
innodb_doublewrite=1
bind-address=0.0.0.0
server-id = 1

# Configuration Galera
wsrep_provider=/usr/lib/galera/libgalera_smm.so
wsrep_provider_options="gcache.size=4G"
wsrep_cluster_address=gcomm://
wsrep_cluster_name='mon-cluster'
wsrep_sst_method=rsync
wsrep_node_name='sql1'

# Tunning InnoDB à personnaliser selon ses besoins
#innodb_buffer_pool_size=4G
#innodb_file_per_table
#innodb_flush_log_at_trx_commit=2
innodb_log_file_size=100M

/usr/bin/galera_new_cluster

service mysql restart

MariaDB [(none)]> SHOW STATUS LIKE  'wsrep_cluster_size';
+--------------------+-------+
| Variable_name      | Value |
+--------------------+-------+
| wsrep_cluster_size | 0     |
+--------------------+-------+
1 row in set (0.00 sec)

 SHOW VARIABLES LIKE 'wsrep_on';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| wsrep_on      | OFF   |
+---------------+-------+
1 row in set (0.00 sec)

set GLOBAL wsrep_on=on;
Query OK, 0 rows affected (0.00 sec)

SHOW VARIABLES LIKE 'wsrep_on';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| wsrep_on      | ON    |
+---------------+-------+
1 row in set (0.00 sec)

wsrep_on=on

MariaDB [(none)]> show variables like 'wsrep_on';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| wsrep_on      | ON    |
+---------------+-------+
1 row in set (0.00 sec)

MariaDB [(none)]> show status like 'wsrep_cluster_size';
+--------------------+-------+
| Variable_name      | Value |
+--------------------+-------+
| wsrep_cluster_size | 1     |
+--------------------+-------+
1 row in set (0.00 sec)

mysql> SHOW STATUS LIKE 'wsrep_local_state_comment';
+---------------------------+--------+
| Variable_name             | Value  |
+---------------------------+--------+
| wsrep_local_state_comment | Synced |
+---------------------------+--------+
1 row in set (0,01 sec)

wsrep_cluster_address=gcomm://srv1

server-id = 2

/etc/init.d/mysql restart

MariaDB [(none)]> SHOW STATUS LIKE 'wsrep_local_state_comment';
+---------------------------+--------+
| Variable_name             | Value  |
+---------------------------+--------+
| wsrep_local_state_comment | Synced |
+---------------------------+--------+
1 row in set (0.01 sec)

MariaDB [(none)]> show status like 'wsrep_cluster_size';
+--------------------+-------+
| Variable_name      | Value |
+--------------------+-------+
| wsrep_cluster_size | 2     |
+--------------------+-------+
1 row in set (0.01 sec)

10-3-2. Clustering Galera Cluster avec MySQL▲

apt-key adv --keyserver keyserver.ubuntu.com --recv BC19DDBA

deb http://releases.galeracluster.com/mysql-wsrep-VERSION/DIST RELEASE main
deb http://releases.galeracluster.com/galera-3/DIST RELEASE main

deb http://releases.galeracluster.com/mysql-wsrep-5.7/debian stretch main
deb http://releases.galeracluster.com/galera-3/debian stretch main

apt-get install mysql-wsrep-5.7 galera-3 galera-arbitrator-3

service mysql stop

mysqld_bootstrap

10-3-3. Maintenance : perte de srv2▲

MariaDB [test]> select * from essai;
ERROR 1047 (08S01): WSREP has not yet prepared node for application use
MariaDB [test]>

safe_to_bootstrap : 0

safe_to_bootstrap : 1

10-3-4. Maintenance : perte de srv1▲

10-3-5. Ajout d'un nouveau serveur▲

10-3-6. Galera arbitrator▲

Le Galera arbitrator est un outil à part, fourni avec Galera Cluster. Celui-ci permet comme son nom l’indique d’arbitrer le cluster. Le démon Galera Arbitrator se nomme garbd. Il n’est pas configuré par défaut. Sa configuration est simple, il faut éditer le fichier /,etc/default/garb.

Il faudra décommenter les lignes :

 

Sélectionnez

GALERA_NODES

et :

 

Sélectionnez

GALERA_GROUP

GALERA_GROUP devra contenir le même nom du cluster mentionné dans la ligne wsrep_cluster_name du fichier de configuration de Galera.

Il va gérer la notion de quorum (rôle d'arbitrage). En cas de coupure de liaison entre deux centres de données, ceux-ci vont pouvoir continuer à fonctionner chacun de leur côté et donc de manière indépendante. En conséquence, les données vont commencer à différer. Cette situation se nomme Split Brain : chaque serveur pense que l'autre ne fonctionne plus. Soit, les serveurs vont s'arrêter ou passer en lecture seule, soit ils vont fonctionner de façon autonome et cela posera un problème. Quel sera le nœud dont les données sont légitimes ? C’est là qu’intervient le quorum : en étant une machine indépendante, il y aura toujours une autorité contrôlant la légitimité des données. Si le quorum de machines minimal n'est pas présent, ou qu'une machine ne peut pas contacter la machine gérant le quorum,le système va se bloquer ou passer en lecture seule.

Avec trois serveurs, vous n’aurez pas besoin de l’arbitrator. Il est réellement nécessaire dans deux cas :

• vous avez un nombre pair de nœuds ;
• vous effectuez des sauvegardes via la méthode State Snapshot Transfer (SST).

10-3-7. Perte d’un nœud dans une configuration à plus de deux machines▲

10-3-8. Percona XtraDB cluster▲

10-4-1. Sauvegarde par mysqldump▲

mysqldump –all-databases -u root -p mot_de_passe >fichier.sql

mysqldump -u root -p mot_de_passe nom_de_la base>fichier.sql

10-4-2. Restauration d'une sauvegarde mysqldump▲

mysql -u root -p mot_de_passe <fichier.sql

mysql -u root -p mot_de_passe nom_de_la_base <fichier.sql

mysqldump –all-databases -u root -p mot_depasse |gzip >fichier.sql.gz

zcat fichier.sql.gz| mysql -u root -p mot_de_passe

10-4-3. Sauvegarde avec Percona XtraBackup▲

xtrabackup --backup –target-dir=backup-full –user=utilisateur --password=mot_de_passe

[xtrabackup]
user=<utilisateur>
password=<mot de passe>

completed OK!

xtrabackup --prepare --target-dir=backup-full

completed OK!

service mysql stop

xtrabackup --copy-back --target-dir=backup-full

chown -R mysql:mysql varlib/mysql/*

service mysql start

xtrabackup --backup --target-dir=backup-full

xtrabackup --backup –target-dir=backup-increment1 --incremental-basedir=backup-full

xtrabackup --prepare --apply-log-only --target-dir=backup-full

xtrabackup --prepare --apply-log-only –target-dir=backup-full --incremental-dir=backup-increment1

xtrabackup --backup –target-dir=backup-full
xtrabackup --backup –target-dir=backup-increment1 –incremental-basedir=backup-full
xtrabackup --backup –target-dir=backup-increment2 –incremental-basedir=backup-increment1

xtrabackup --prepare --apply-log-only –target-dir=backup-full
xtrabackup --prepare --apply-log-only –target-dir=backup-full –incremental-dir=backup-increment1
xtrabackup --prepare  -–target-dir=backup-full –incremental-dir=backup-increment2

PosGresSQL intègre la gestion de réplication. Le fonctionnement est similaire aux clusters MySQL en se basant sur les journaux de transactions.

Documentation sur la haute disponibilité, la répartition de charges, et la réplication pour PostGresSQL.

Microsoft SQL Server permet également la mise en place d'un cluster. Ceci se fera avec le rôle AD « cluster de basculement » (Failover Clustering).

La répartition de charge (appelé aussi load balancing) permet :

• d’étaler la charge de travail sur plusieurs systèmes ;
• rendre transparent une panne matérielle ou au moins faire en sorte qu'il n'y ait pas de coupure de service, même si le service peut être dégradé.

Un load-balancer a pour rôle de répartir la charge de travail entre les différents nœuds participants. Il pourra utiliser un algorithme simple dit statique comme utiliser les machines à tour de rôle ou utiliser un algorithme dit dynamique qui va s'adapter à la situation.

Pour qu'un système à charge répartie puisse rester en ligne, il ne doit y avoir aucun point de défaillance. Cela signifie que tous les éléments indispensables au système doivent être redondants, comme un nombre suffisant de machines sur un système de fichiers répartis, une redondance sur le système de load balancing, une redondance électrique ou de datacenter.

11-3-1. Le DNS Round-Robin▲

11-3-2. Heartbeat▲

apt-get install heartbeat

logfile         /var/log/ha-log
keepalive       2
deadtime        10
bcast           eth1
node            srv1 srv2
auto_failback   no
respawn         root /usr/lib/heartbeat/ipfail
apiauth         ipfail gid=root uid=root

srv1 Ipaddr::192.168.1.200 apache2

srv1 Filesystem::192.x.x.x:/partage_distant::/point_de_montage::nfs

auth 1
1 sha1 "le precieux"

chmod 600 /,etc/heartbeat/haresources

systmctl disable apache2

systemctl stop apache2

systemctl start heartbeat

...
eth0:0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.200  netmask 255.255.255.0  broadcast 192.168.1.255
        ether 08:00:27:ba:77:c4  txqueuelen 1000  (Ethernet)
...

systemctl enable heartbeat

cl_status hbstatus -v

version:        3.0.6 (node: 958e11be8686759f1b99204c17812f2c2633b169)
managed by:     "haresources"

srv2    active  (nodetype: normal)
        eth1    up

srv1    dead  (nodetype: normal)
        eth1    up

11-3-3. Pacemaker▲

11-3-4. Corosync▲

11-3-5. Corosync/Pacemaker▲

11-3-6. Keepalived▲

~# sysctl -p
net.ipv4.ip_forward = 1
net.ipv4.ip_nonlocal_bind = 1
~#

apt-get install keepalived

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 101
    priority 100
    virtual_ipaddress {
        192.168.1.200
    }
}

vrrp_sync_group VG1 {
    group {
        VI_1
        VI_2
    }
}

global_defs {
    notification_email {
        <adresse mail>
    }
    notification_email_from <adresse émettrice>
    smtp_server <adresse ip/fqdn serveur mail>
    smpt_connect_timeout 30
    router_id 100
}

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 101
    priority 100
    virtual_ipaddress {
        192.168.1.200
    }
   virtual_server 192.168.1.200 80 {
      lb_algo wlc
      lb_kind DR
      #sorry_server 192.168.1.199
   }
   real_server 192.168.1.201 80 {
     weight 1
     inhibit_on_failure
   }
   real_server 192.168.1.202 80 {
     weight 2
     inhibit_on_failure
   }
}

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 101
    priority 100
    virtual_ipaddress {
        192.168.1.200
    }
   virtual_server 192.168.1.200 80 {
      lb_algo wlc
      lb_kind DR
      #sorry_server 192.168.1.199
   }
   track_script {
      test_ip
   }
   real_server 192.168.1.201 80 {
     weight 1
     inhibit_on_failure
   }
   real_server 192.168.1.202 80 {
     weight 2
     inhibit_on_failure
   }
}

vvrp_script test_cluster {
  script "/usr/share/test_cluster.sh"
  interval 5 # test toutes les 5 secondes
 fall 2 # nécessite deux échecs pour déclarer un KO
 rise 2 # nécessite deux réussites  pour déclarer un OK
}

#!/bin/bash
if ping -c 1 192.168.1.201 >/dev/null
then
 exit 0;
else
 exit 1;
fi

#!/bin/bash
test=$(wget -qO- 192.168.1.201>>/dev/null;echo $?)
if $test=0
then exit 0 ;
else exit 1 ;
fi

#!/bin/bash

TYPE=$1
NAME=$2
STATE=$3

case $STATE in
        "MASTER") service apache2 start
                  exit 0
                  ;;
        "BACKUP") service apache2 stop
                  exit 0
                  ;;
        "FAULT")  service apache2 stop
                  exit 0
                  ;;
        *)        echo "unknown state"
                  exit 1
                  ;;
esac

La plupart des services (au sens démon) seront capables de vous envoyer des mails en cas de problèmes. Cela peut être un moyen simple, mais pas forcément fiable. Exemple si le module générant les erreurs ou le serveur mail sont en défaut, vous ne recevrez plus les alertes. Ce système peut suffire si vous pouvez recevoir un rapport de bon fonctionnement. Dans ce cas, la non-réception de celui-ci indiquera un problème.

syslog est un protocole de gestion de logs. Ceci permet à un logiciel de centraliser ses logs vers un serveur syslog plutôt que de les gérer dans son coin. La plupart des services sont capables de se greffer sur un serveur syslog. syslog gère dans ses messages des niveaux de priorité et de gravité.

Utiliser syslog dans un logiciel est simple, la fonction libc syslog le permettant.

Il existe des utilitaires permettant l'analyse des messages syslog.

syslog reste une solution bas niveau (c.-à-d. pour l'administrateur système) avec ses avantages et ses inconvénients.

Un tutoriel sur syslog.

Nagios est un logiciel de supervision libre faisant référence. Il permet une surveillance centralisée de plusieurs équipements. Il se compose de son moteur de supervision, d'une interface web permettant une vue globale, et de greffons dédiés à la surveillance d'éléments précis, les plus simples étant la réponse au ping, l'état S.M.A.R.T d'un disque, l'état d'occupation disque, mémoire ; ainsi que des greffons plus poussés comme la présence d'un processus, il est possible de créer ses propres greffons.

Il existe des options similaires gratuites et payantes.

Un tutoriel sur Nagios.

Prometheus est un logiciel de surveillance et d'alerte libre créé à l'origine par SoundCloud pour ses besoins internes.

Grafana est un logiciel libre de génération de tableaux de bord et graphiques.

Les deux produits vont utiliser des informations stockées dans une base de données, dans notre cas la base sera alimentée par Prometheus, puis exploitée par Grafana.

Les deux solutions couplées vous permettront de générer votre propre système de surveillance personnalisé comme présenté dans ce tutoriel.

Si vous trouvez que Nagios est une usine à gaz, vous pourrez utiliser des outils existants ou développer votre propre solution maison.

Il vous faudra commencer par déterminer les points à surveiller. Nous mettons de côté la réponse au ping, le contrôle de l'espace disque qui sont les éléments de base à surveiller et considérés comme des prérequis.

Si nous devons surveiller le fonctionnement d'un site web par exemple, il vous faudra automatiser un dialogue avec celui-ci avec cUrl (client URL request Library) par exemple de façon à vérifier le comportement normal du site. Une simple requête HTTP ne permettra que de tester si le serveur HTTP est opérationnel, mais ne permettra pas de détecter un site en erreur.

Pour une solution à grande échelle, Nagios sera le produit adapté, car considéré comme un standard, il pourra être pris en main par n'importe quel administrateur système et non pas uniquement par vous suite à la mise en place d'une solution « exotique ».