Plus que jamais, dans un monde ultraconnecté où tant de choses dépendent de l'informatique et d'Internet, il est primordial de disposer d'environnements hautement disponibles, redondants et fiables. L'objectif de ce livre est de fournir aux ingénieurs système toutes les bases permettant de construire des environnements de Haute Disponibilité, tant du point de vue de l'infrastructure que du point de vue des services, basés sur le système d'exploitation Linux.

Selon les principes et les outils DevOps, les auteurs présentent un exemple d'application fil rouge permettant d'étudier la façon de faire évoluer de concert une application et l'infrastructure sous-jacente, pour les rendre les plus fiables et les plus accessibles possibles, en s'appuyant sur les dernières technologies.

Tous les éléments de conception d'une plateforme et d'une application redondantes sont ainsi abordés.

Le lecteur peut ainsi appréhender concrètement la définition d'une application écrite en Java et tournant sous Tomcat, la mise en place d'une architecture matérielle fonctionnelle pour la supporter, la redondance des services système et réseau de base (RAID, agrégats réseau, DNS…), l'automatisation de la construction et du déploiement des images de l'application avec Docker et Ansible ou encore la haute disponibilité du réseau, des répartiteurs de charge et des adresses IP avec NGINX, HAProxy, le protocole VRRP et Quagga.

Dans la suite du livre, les auteurs décrivent le passage à l'orchestration avec un cluster Kubernetes, le déploiement d'un cluster avec une solution de stockage réseau redondant basée sur un cluster NFS et XFS, ainsi que la création de clusters de bases de données MariaDB et les affinités de sessions.

Chaque chapitre du livre est agrémenté d'exemples pratiques dont l'ensemble du code est proposé en téléchargement sur l'espace GitHub des auteurs.



Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (213 Ko)

Avant-propos

1. 1. Introduction
2. 2. Contenu de ce livre

Application standalone

1. 1. L’application fil rouge
   1. 1.1 L’architecture de l'application web
   2. 1.2 Le code
      1. 1.2.1 L’objet TodoItem
      2. 1.2.2 Les noms des classes
      3. 1.2.3 Le modèle MVC
      4. 1.2.4 La gestion des fichiers téléchargés
      5. 1.2.5 La configuration (Spring profile)
2. 2. Construction du serveur tout-en-un
   1. 2.1 Installation de l'application
      1. 2.1.1 Apache Tomcat
      2. 2.1.2 MariaDB
      3. 2.1.3 Construction de l'application
   2. 2.2 Exposition Internet
   3. 2.3 Critique du design applicatif
3. 3. Quelques problèmes de ce modèle tout-en-un
   1. 3.1 Partage des ressources
   2. 3.2 Configuration hardware non optimale
   3. 3.3 Tous ses œufs dans le même panier

Infrastructure et services de base

1. 1. Qu'est-ce que la haute disponibilité ?
   1. 1.1 Tolérance aux pannes
   2. 1.2 Taux de disponibilité
   3. 1.3 Éléments à prendre en compte
   4. 1.4 Rôles et responsabilités
2. 2. Infrastructure en haute disponibilité
   1. 2.1 Exemple d'architecture
   2. 2.2 Caractéristiques matérielles d’un serveur
   3. 2.3 Répartition des serveurs
   4. 2.4 Serveurs physiques ou virtuels
   5. 2.5 Tester sans serveurs
   6. 2.6 Besoins et plan d'adressage
      1. 2.6.1 Serveurs
      2. 2.6.2 Réseau
      3. 2.6.3 Détails
3. 3. Installation de base
   1. 3.1 Réseau VirtualBox
   2. 3.2 Installation standard
      1. 3.2.1 Image Ubuntu
      2. 3.2.2 Disques
      3. 3.2.3 Réseau Netplan
      4. 3.2.4 Utilisateurs
      5. 3.2.5 Installation d'Ansible
   3. 3.3 Clonage
4. 4. Agrégats réseau
   1. 4.1 Vitesse et tolérance aux pannes
   2. 4.2 Considérations matérielles
   3. 4.3 Modes de fonctionnement
   4. 4.4 Configuration
      1. 4.4.1 Configuration manuelle
      2. 4.4.2 Utiliser Netplan
      3. 4.4.3 État de l'agrégat
5. 5. Serveur DNS
   1. 5.1 Comment Linux résout-il les adresses ?
   2. 5.2 DNS primaires et secondaires
   3. 5.3 Configuration
      1. 5.3.1 DNS primaire
      2. 5.3.2 DNS secondaire
      3. 5.3.3 Test
      4. 5.3.4 Resolver Systemd
      5. 5.3.5 Automatisation

Les containers

1. 1. Cahier des charges
2. 2. Isolation et container
   1. 2.1 Principe
   2. 2.2 Container et machine virtuelle
   3. 2.3 Namespace
   4. 2.4 Cgroup
   5. 2.5 Montage en union
   6. 2.6 Image applicative
   7. 2.7 Couches d'images
   8. 2.8 Docker
   9. 2.9 Le projet OCI
3. 3. Préparer l'environnement
   1. 3.1 Installer Docker
   2. 3.2 Installer un registry Docker
      1. 3.2.1 Créer le stockage
      2. 3.2.2 Obtenir une clé et un certificat
      3. 3.2.3 Démarrer le registry
      4. 3.2.4 Tester
      5. 3.2.5 Automatiser
4. 4. Construire l'image
   1. 4.1 Adaptation du code
   2. 4.2 Dockerfiles
      1. 4.2.1 Builder
      2. 4.2.2 Tomcat
      3. 4.2.3 Image applicative
   3. 4.3 Build
   4. 4.4 Premier test
   5. 4.5 Utiliser le registry
   6. 4.6 Automatisation
      1. 4.6.1 Image pour MariaDB
      2. 4.6.2 Image h2
5. 5. Déployer les containers
   1. 5.1 MariaDB
      1. 5.1.1 Stockage
      2. 5.1.2 Démarrage
   2. 5.2 eni-todo
      1. 5.2.1 Emplacement des fichiers téléchargés
      2. 5.2.2 Démarrage manuel
   3. 5.3 Automatisation
      1. 5.3.1 Configuration YAML
      2. 5.3.2 Déploiement
6. 6. Bilan

Exposition et répartition

1. 1. Exposer ses services
   1. 1.1 Problématique
   2. 1.2 Architecture de base
2. 2. Reverse proxy
   1. 2.1 Pourquoi utiliser un reverse proxy ?
   2. 2.2 Choix du reverse proxy
   3. 2.3 Installation
   4. 2.4 Configuration
      1. 2.4.1 nginx.conf
      2. 2.4.2 Certificats
   5. 2.5 Automatisation
      1. 2.5.1 Configuration YAML
      2. 2.5.2 Certificats
      3. 2.5.3 Déploiement
      4. 2.5.4 Test
      5. 2.5.5 Reboot
3. 3. Répartition de charge
   1. 3.1 Présentation
   2. 3.2 Objectifs
   3. 3.3 Architecture en haute disponibilité
4. 4. Solution de répartition de charge
   1. 4.1 Choix des produits
   2. 4.2 HAProxy
      1. 4.2.1 Présentation
      2. 4.2.2 Architecture
      3. 4.2.3 Exemple
   3. 4.3 VRRP avec Keepalived
      1. 4.3.1 Présentation de Keepalived
      2. 4.3.2 Présentation de VRRP
      3. 4.3.3 Exemple
   4. 4.4 Installation manuelle
      1. 4.4.1 installation des packages
      2. 4.4.2 Paramétrer le noyau et les limites
      3. 4.4.3 Configuration du pare-feu
   5. 4.5 Automatisation
      1. 4.5.1 Installation et paramétrage des composants
      2. 4.5.2 Vérification des arborescences
      3. 4.5.3 Contrôle des services
      4. 4.5.4 Configuration des VIP
      5. 4.5.5 Test final
   6. 4.6 Bilan
5. 5. Exposition Internet
6. 6. Solution d'exposition Internet avec Quagga
   1. 6.1 Implémentation
   2. 6.2 Installation et configuration
   3. 6.3 Test
   4. 6.4 Automatisation

Orchestration

1. 1. Introduction
2. 2. Abstractions d’orchestration
   1. 2.1 Abstraction du serveur
   2. 2.2 Abstraction de l'application
   3. 2.3 Abstraction du réseau
   4. 2.4 Abstraction du stockage
   5. 2.5 Rappel à la réalité
3. 3. Automatisation ou orchestration ?
4. 4. Bataille des orchestrateurs
5. 5. Mécanismes des environnements distribués
   1. 5.1 Consensus
   2. 5.2 Paxos
   3. 5.3 Raft
6. 6. Scheduler
7. 7. Premiers pas avec Kubernetes
   1. 7.1 Architecture
   2. 7.2 Version allégée : Minikube
      1. 7.2.1 Installation
      2. 7.2.2 Add-ons
      3. 7.2.3 minikube dashboard
      4. 7.2.4 minikube docker-env
      5. 7.2.5 minikube logs
      6. 7.2.6 minikube IP
      7. 7.2.7 minikube service
      8. 7.2.8 minikube update-context
8. 8. Initiation à Kubernetes
   1. 8.1 kubectl
   2. 8.2 Appels à l'API
   3. 8.3 Configuration du client
   4. 8.4 Manipulation des ressources
   5. 8.5 Traces du pod

Déploiement avec Kubernetes

1. 1. Introduction
2. 2. Du pod aux déploiements
   1. 2.1 Pod
      1. 2.1.1 Sondes et contrôle de santé
      2. 2.1.2 Classes de qualité de service, limits et requests
   2. 2.2 ReplicaSet
   3. 2.3 Déploiement
3. 3. Services et Endpoints
   1. 3.1 Service de type ClusterIP
   2. 3.2 Service de type NodePort
   3. 3.3 Endpoints
4. 4. Secret et ConfigMap
   1. 4.1 Monter des ConfigMaps et des secrets
   2. 4.2 Utilisation des ConfigMap et Secret dans les variables d'environnement
5. 5. StatefulSet
6. 6. PersistentVolume
7. 7. PersistentVolumeClaim
8. 8. StorageClass
9. 9. Routes ingress
   1. 9.1 Le contrôleur des flux entrant (ingress controller)
   2. 9.2 Objet ingress
10. 10. Job et CronJob
11. 11. DaemonSet

Stockage en haute disponibilité

1. 1. Disponibilité du stockage
   1. 1.1 Problématique
   2. 1.2 Cahier des charges
   3. 1.3 Solution
   4. 1.4 Architecture
      1. 1.4.1 DRBD et cluster
      2. 1.4.2 XFS, quotas et NFSv4
2. 2. RAID
   1. 2.1 Principe
   2. 2.2 RAID matériel vs RAID logiciel
   3. 2.3 RAID-0, RAID-1 et RAID-5
   4. 2.4 Manipulation d'un RAID-5
3. 3. Cluster NFS-HA
   1. 3.1 Installation des packages
   2. 3.2 Configuration du réseau
   3. 3.3 Création du cluster
   4. 3.4 Vérification
   5. 3.5 Configuration du stockage
      1. 3.5.1 LVM
      2. 3.5.2 DRBD
   6. 3.6 Ressources Pacemaker
      1. 3.6.1 DRBD
      2. 3.6.2 LVM
      3. 3.6.3 Système de fichiers
      4. 3.6.4 NFS
      5. 3.6.5 Adresse IP
   7. 3.7 Contraintes Pacemaker
   8. 3.8 Test de bascule
4. 4. Projets XFS
   1. 4.1 Ajout manuel
   2. 4.2 Test NFS
   3. 4.3 Split-brain
   4. 4.4 Automatisation

Mise en place d’un cluster Kubernetes

1. 1. Introduction
2. 2. Topologie
   1. 2.1 Composants de base
   2. 2.2 Répartition
      1. 2.2.1 Quorum et performances
      2. 2.2.2 Masters
      3. 2.2.3 Nodes
      4. 2.2.4 Positionnement
      5. 2.2.5 Topologie pour eni-todo
3. 3. Préparation
   1. 3.1 Rappels
   2. 3.2 HAProxy
   3. 3.3 Préparation des serveurs
      1. 3.3.1 Configuration système
      2. 3.3.2 Configuration du pare-feu
      3. 3.3.3 Automatisation
4. 4. Construction
   1. 4.1 Images de Kubernetes
   2. 4.2 Premier master
      1. 4.2.1 Bootstrap
      2. 4.2.2 Flannel
   3. 4.3 Deuxième et troisième masters
   4. 4.4 Modification du contrôleur
   5. 4.5 Ajout des nodes
   6. 4.6 Test
      1. 4.6.1 Premier déploiement
      2. 4.6.2 Première exposition
      3. 4.6.3 Ajout des pods
      4. 4.6.4 Résolution DNS interne
   7. 4.7 Routeur ingress
      1. 4.7.1 Principe
      2. 4.7.2 Installation
      3. 4.7.3 Premier ingress
      4. 4.7.4 Mode host network
5. 5. Procédures additionnelles
   1. 5.1 Crash ou arrêt sale d'un node
   2. 5.2 Arrêt propre d’un node
   3. 5.3 Destruction d'un cluster

Intégration finale

1. 1. Introduction
2. 2. Volumes persistants
   1. 2.1 Cluster NFS-HA
   2. 2.2 Approvisionner des volumes persistants
3. 3. Registry Docker
   1. 3.1 Architecture
   2. 3.2 Génération d’un secret
   3. 3.3 Déploiement
      1. 3.3.1 Demande de volume persistant
      2. 3.3.2 Création d’un déploiement
      3. 3.3.3 Création d’un service
   4. 3.4 Exposition
      1. 3.4.1 Ajout d’une route ingress
      2. 3.4.2 Exposition via HAProxy
      3. 3.4.3 Test
4. 4. Base de données
   1. 4.1 Problématique
   2. 4.2 Galera
   3. 4.3 Déploiement
   4. 4.4 Création de db-todo
   5. 4.5 Problème de redémarrage
5. 5. eni-todo
   1. 5.1 Adaptations
   2. 5.2 Construction de l’image
   3. 5.3 Création d’un compte de service
   4. 5.4 Déploiement
      1. 5.4.1 Demande de volume persistant
      2. 5.4.2 Création du service
      3. 5.4.3 Déploiement
   5. 5.5 Exposition
      1. 5.5.1 Affinité et persistance
      2. 5.5.2 Création d’une configuration ingress
      3. 5.5.3 Configuration de HAProxy
   6. 5.6 Test final
6. 6. Bilan

Aller plus loin

1. 1. Introduction
2. 2. Plan de reprise d'activité
   1. 2.1 Quand le désastre arrive
   2. 2.2 Définition
   3. 2.3 Mesures
   4. 2.4 Pratiques DevOps
3. 3. Sauvegardes
   1. 3.1 Redondance vs sauvegarde
   2. 3.2 Que sauvegarder ?
   3. 3.3 GitOps
   4. 3.4 SaaS
4. 4. Sécurité
   1. 4.1 Container et root
      1. 4.1.1 Exemple d'exploit
      2. 4.1.2 Solutions
      3. 4.1.3 Le contexte de sécurité (securityContext)
   2. 4.2 Réseau Kubernetes
   3. 4.3 Utilisateurs et droits
      1. 4.3.1 RBAC
      2. 4.3.2 Utilisateurs
   4. 4.4 Mises à jour
   5. 4.5 Firewalls, proxies, routeurs
   6. 4.6 Applications
5. 5. Surveillance
   1. 5.1 Métriques
   2. 5.2 Traces
6. 6. Stockage
7. 7. PaaS
   1. 7.1 Installer OKD
   2. 7.2 Instancier des images Docker
   3. 7.3 Du build au déploiement de eni-todo
   8. Index