Retour au site

Uptime Formation - Formations Uptime

Supports de formation : Elie Gavoty, Alexandre Aubin et Hadrien Pélissier
Sous licence CC-BY-NC-SA - Formations Uptime


Table des matières :

Environnement de travail

Pour cette formation en distanciel nous utiliserons les outils suivants:

  • L’espace de travail Teams fournis pour la formation dans lequel a lieu les conférences Videos/Audio. Il permet également de faire des remarques et partager des fichier entre nous.
  • Ce site internet qui contient tout le contenu de la formation. Le site internet est maintenu à jour tout au long de la formation (pensez à recharger les pages régulièrement) vous pourrez l’imprimer en PDF à la fin.
  • Pour toute la partie pratique nous utiliserons des serveurs distants accessibles en mode graphique(VNC) via le site guacamole.formation.dopl.uk

Serveurs distants

L’intérêt des serveurs distant est double:

  • L’environnement est fiable et identique pour tout le monde ce qui évitera les bugs spécifiques en fonction des environnements de chacun.
  • Ils facilite le travail à distance car tous les stagiaires peuvent voir l’écran du formateur et inversement le formateur peut intervenir rapidement sur les machines de tous les stagiaires.

Connexion à Guacamole

  • Connectez-vous à guacamole.dopl.uk avec comme login votre prenomnom (sans point ni tirets) et comme mot de passe devops101.

Normalement vous devriez avoir deux connexions disponibles:

  • Ouvrez chacune des connexions dans un nouvel onglet ou une nouvelle fenêtre.

Vous pouvez désormais suivre les actions du formateur et les reproduire de votre côté sur le serveur.

Pour la sauvegarde de votre code nous créerons un dépôt git sur github au cours de la formation.

Introduction

Introduction

DevOps

Le nouveau paradigme de l’informatique

Introduction DevOps

La culture et la pratique du DevOps


A propos de moi

A propos de vous

  • “Profil” : votre environnement technique initial
  • Besoins : ce que vous aimeriez faire, avez besoin de savoir faire
  • Attentes de cette formation

DevOps : définition

“Le DevOps est un mouvement qui s’attaque au conflit existant structurellement entre le développement de logiciels et les opérations. Ce conflit résulte d’objectifs et de motivations divergents. Le DevOps améliore la collaboration entre les départements du développement et des opérations et rationalise l’ensemble de l’organisation. (Citation de Hütterman 2012 - Devops for developers)”

L’agilité en informatique

  • Traditionnellement la qualité logicielle provient :

    • d’une conception détaillée en amont = création d’un spécification détaillée
    • d’un contrôle de qualité humain avant chaque livraison logicielle basé sur une processus = vérification du logiciel par rapport à la spécification
  • Problèmes historiques posé par trop de spécification et validation humaine :

    • Lenteur de livraison du logiciel (une version par an ?) donc aussi difficulté de fixer les bugs et problèmes de sécurité a temps
    • Le travail des développeur·euses est dominé par des process formels : ennuyeux et abstrait
    • difficulté commerciale : comment répondre à la concurence s’il faut 3 ans pour lancer un produit logiciel.
Solution : développer de façon agile c’est à dire itérative
  • Sortir une version par semaine voir par jour
  • Créer de petites évolution plutôt que de grosses évolution
  • Confronter en permanence le logiciel aux retours clients et utilisateurs

Mais l’agilité traditionnelle ne concerne pas l’administration système.

La motivation au coeur du DevOps : La célérité

  • La célérité est : la rapidité (itérative) non pas seulement dans le développement du logiciel mais plus largement dans la livraison du service au client:

Exemple : Netflix ou Spotify ou Facebook etc. déploient une nouvelle version mineure de leur logiciel par jour.

  • Lorsque la concurrence peut déployer des innovations en continu il devient central de pouvoir le faire.

Le problème que cherche à résoudre le DevOps

La célérité et l’agrandissementest sont incompatibles avec une administration système traditionnelle:

Dans un DSI (département de service informatique) on organise ces activités d’admin sys en opérations:

  • On a un planning d’opération avec les priorités du moment et les trucs moins urgents
  • On prépare chaque opération au minimum quelques jours à l’avance.
  • On suit un protocole pour pas oublier des étapes de l’opération (pas oublier de faire une sauvegarde avant par exemple)

La difficulté principale pour les Ops c’est qu’un système informatique est:

  • Un système très complexe qu’il est quasi impossible de complètement visualiser dans sa tête.
  • Les évènements qui se passe sur la machines sont instantanés et invisibles
  • L'état actuel de la machine n’est pas ou peu explicite (combien d’utilisateur, machine pas connectée au réseau par exemple.)
  • Les interactions entre des problèmes peu graves peuvent entrainer des erreurs critiques en cascades.

On peut donc constater que les opérations traditionnelles implique une culture de la prudence

  • On s’organise à l’avance.
  • On vérifie plusieurs fois chaque chose.
  • On ne fait pas confiance au code que nous donnent les développeur·euses.
  • On suit des procédures pour limiter les risques.
  • On surveille l’état du système (on parle de monitoring)
  • Et on reçoit même des SMS la nuit si ya un problème :S

Bilan

Les opérations “traditionnelles”:

  • Peuvent pas aller trop vite car il faut marcher sur des oeufs.
  • Les Ops veulent pas déployer de nouvelles versions trop souvent car ça fait plein de boulot et ils prennent des risques (bugs / incompatilibités).
  • Quand c’est mal organisé ou qu’on va trop vite il y a des catastrophes possibles.

L’objectif technique idéal du DevOps : Intégration et déploiement continus (CI/CD)

Du côté des développeur·euses avec l’agilité on a déjà depuis des années une façon d’automatiser pleins d’opérations sur le code à chaque fois qu’on valide une modification.

  • Chaque modification du code est validée dans le gestionnaire de version Git.
  • Ensuite est envoyée sur le dépot de code commun.
  • Des tests logiciels se lancent automatiquement pour s’assurer qu’il n’y a pas de bugs ou de failles.
  • Les développeur·euses sont avertis des problèmes.

C’est ce qu’on appelle l’intégration continue.

Le principe central du DevOps est d’automatiser également les opérations de déploiement et de maintenance en se basant sur le même modèle.

Mais pour que ça fonctionne il faut résoudre des défi techniques nouveau => innovations

Renforcer la collaboration

Équipes transversales

Dans le cadre d’un produit logiciel, les administrateurs systèmes sont rassemblées avec le développement et le chef produit : tout le monde fait les réunions ensemble pour se parler et se comprendre.

Culture de la polyvalence

  • Les développeur·euses peuvent plus facilement créer un environnement réaliste pour jouer avec et comprendre comment fonctionne l’infrastructure de production (ils progressent dans l’administration système et la compréhension des enjeux opérationnels).

  • Les adminsys apprennent à programmer leurs opérations de façon puissante il deviennent donc plus proche de la logique des développeur·euses. (grace à l’Infrastructure as Code)


Le profil DevOps

Par abus de langage on dit un ou une DevOps pour parler d’un métier spécifique dans une entreprise. Je dis que je suis DevOps sur mon CV par exemple.

Vous pouvez retenir :

Un·e DevOps c’est un·e Administrateur·ice Système qui programme ses outils.


Le profil DevOps

Il faut être polyvalent : bien connaître l’administration système Linux mais aussi un peu la programmation et le développement.

Il faut connaître les nouvelles bonnes pratiques et les nouveaux outils cités précédemment.


En résumé

  • Un profil ? Un hybride de dev et d’ops…
  • Une méthode ? Infra-as-Code, continuous integration and delivery (CI/CD), conteneurisation
  • Une façon de virer des adminsys… ?

Réancrer les programmes dans la réalité de leur utilisation

“Machines ain’t smart. You are!” Comment dire correctement aux machines quoi faire ?


Solutions techniques

Quelques expressions que vous allez beaucoup entendre:

  • Technologies de Cloud (infrastructures à la demande)
  • CI / CD
  • Infrastructure as Code
  • Containerisation

Le cloud

Plutôt que d'installer manuellement de nouveaux serveurs linux pour faire tourner des logiciels on peut utiliser des outils pour faire apparaître de nouveaux serveurs à la demande.

Du coup on peut agrandir sans effort l’infrastructure de production pour délivrer une nouvelle version

C’est ce qu’on appelle le IaaS (Infrastructure as a service)

CI / CD

(intégration continue et déploiement continu)

  • Accélérer la livraison des nouvelles versions du logiciel.

  • Des tests systématiques et automatisés pour ne pas se reposer sur la vérification humaine.

  • Un déploiement progressif en parallèle (Blue/Green) pour pouvoir automatiser le Rollback et être serein.

  • A chaque étape le code passe dans un Pipeline de validation automatique.


Infrastructure as code

  • Permet de régler un problème de l’administration système : Difficulté de connaître l’état du système à un instant T, ce qui augmente les risques.

  • Plutôt que d’appliquer des commandes puis d’oublier si on les a appliquées, On décrit le système d’exploitation (l’état du linux) dans un fichier et on utilise un système qui applique cette configuration explicite à tout moment.

  • Permet aux Ops/AdminSys de travailler comme des développeur·euses (avec une usine logicielle et ses outils)

Infrastructure As Code

Un mouvement d’informatique lié au DevOps et au cloud :

  • Rapprocher la production logicielle et la gestion de l’infrastructure
    • Rapprocher la configuration de dev et de production (+ staging)
    • Assumer le côté imprévisible de l’informatique en ayant une approche expérimentale
    • Aller vers de l’intégration et du déploiement continu et automatisé.

Une façon de définir une infrastructure dans un fichier descriptif et ainsi de créer dynamiquement des services.

  • Du code qui décrit l’état désiré d’un système.
  • Arrêtons de faire de l’admin-sys ad-hoc !

Avantages :

  • Descriptif : on peut lire facilement l'état actuel de l’infra
  • Git ! Gérer les versions de l’infrastructure et collaborer facilement comme avec du code.
  • Tester les instrastructure pour éviter les régressions/bugs
  • Facilite l’intégration et le déploiement continus = vélocité = versions testées puis mises en prod' progressivement et automatiquement dans le cycle DevOps
  • Pas de surprise = possibilité d’agrandir les clusters sans souci !
    • On peut multiplier les machines (une machine ou 100 machines identiques c’est pareil).

Assez différent de l’administration système sur mesure (= méthode de résolution plus ou moins rigoureuse à chaque nouveau bug)


Infrastructure As Code

Concepts proches

  • Infrastructure as a Service (commercial et logiciel)

    • Amazon Web Services, Azure, Google Cloud, DigitalOcean
    • = des VM ou des serveurs dédiés
  • Plateform as a Service - Heroku, cluster Kubernetes Avec une offre d’hébergement de conteneurs, on parle la plupart du temps de Platform as a Service.


L’infrastructure as code

Il s’agit comme son nom l’indique de gérer les infrastructures en tant que code c’est-à-dire des fichiers textes avec une logique algorithmique/de données et suivis grâce à un gestionnaire de version (git).

Le problème identifié que cherche a résoudre l’IaC est un écheveau de difficulées pratiques rencontrée dans l’administration système traditionnelle:

  1. Connaissance limité de l’état courant d’un système lorsqu’on fait de l'administration ad-hoc (manuelle avec des commandes unix/dos).
  • Dérive progressive de l’état des systèmes et difficultés à documenter leur états.
  • Fiabilité limitée et risques peu maîtrisés lors de certaines opérations transversales (si d’autres méchanismes de fiabilisation n’ont pas été mis en place).
  • Problème de communication dans les grandes équipes car l’information est détenue implicitement par quelques personnes.
  1. Faible reproductibilité des systèmes et donc difficulté/lenteur du passage à l’échelle (horizontal scaling).
  • Multiplier les serveurs identiques est difficile si leur état est le résultat d’un processus manuel partiellement documenté.
  • Difficulté à reproduire/simuler l’état précis de l’infrastructure de production dans les contextes de tests logiciels.
  1. Difficultés du travail collaboratif dans de grandes équipes avec plusieurs culture (Dev vs Ops) lorsque les rythmes et les modes de travail diffèrent
  • L’IaC permet de tout gérer avec git et des commits.
  • L’IaC permet aux Ops qui ne le faisait pas de se mettre au code et aux développeur·euses de se confronter plus facilement.
  • L’IaC permet d’accélérer la transformation des infrastructures pour l’aligner sur la livraison logicielle quotidienne (idéalement ;) )

Containerisation

Les conteneurs (Docker et Kubernetes)

Faire des boîtes isolées avec nos logiciels:

  • Un façon standard de packager un logiciel
  • Cela permet d’assembler de grosses applications comme des legos
  • Cela réduit la complexité grâce:
    • à l’intégration de toutes les dépendance déjà dans la boîte
    • au principe d’immutabilité qui implique de jeter les boîtes (automatiser pour lutter contre la culture prudence). Rend l’infra prédictible.

Docker (et un peu LXC)

Il s’agit de mettre en quelques sortes les logiciels dans des boîtes :

  • Avec tout ce qu’il faut pour qu’il fonctionnent (leurs dépendances).

  • Ces boîtes sont fermées (on peut ne peux plus les modifier). On parle d'immutabilité.

  • Si on a besoin d’un nouvelle version on fait un nouveau modèle de boîte. (on dit une nouvelle image docker)

  • Cette nouvelle image permet de créer autant d’instances que nécessaire.


Containerisation - Pourquoi ?

  • L’isolation des containers permet d’éviter que les logiciels s’emmêlent entre eux. (Les dépendances ne rentrent pas en conflit)

  • Les conteneurs non modifiables permettent de savoir exactement l’état de ce qu’on exécute sur l’ordinateur

Le risque de bug diminue énormément : fiabilisation

  • L’agrandissement d’un infrastructure logiciel est beaucoup pour facile lorsqu’on a des boîtes autonomes qu’on peut multiplier.

Docker

Module 2

Docker

Créer et manipuler des conteneurs

Partie 1 - Découverte

0 - Introduction à Docker

Modularisez et maîtrisez vos applications


Introduction

  • La métaphore docker : “box it, ship it”

  • Une abstraction qui ouvre de nouvelles possibilités pour la manipulation logicielle.

  • Permet de standardiser et de contrôler la livraison et le déploiement.

Retour sur les technologies de virtualisation

On compare souvent les conteneurs aux machines virtuelles. Mais ce sont de grosses simplifications parce qu’on en a un usage similaire : isoler des programmes dans des “contextes”. Une chose essentielle à retenir sur la différence technique : les conteneurs utilisent les mécanismes internes du _kernel de l’OS Linux_ tandis que les VM tentent de communiquer avec l’OS (quel qu’il soit) pour directement avoir accès au matériel de l’ordinateur.

  • VM : une abstraction complète pour simuler des machines

    • un processeur, mémoire, appels systèmes, carte réseau, carte graphique, etc.
  • conteneur : un découpage dans Linux pour séparer des ressources (accès à des dossiers spécifiques sur le disque, accès réseau).

Les deux technologies peuvent utiliser un système de quotas pour l’accès aux ressources matérielles (accès en lecture/écriture sur le disque, sollicitation de la carte réseau, du processeur)

Si l’on cherche la définition d’un conteneur :

C’est un groupe de processus associé à un ensemble de permissions.

L’imaginer comme une “boîte” est donc une allégorie un peu trompeuse, car ce n’est pas de la virtualisation (= isolation au niveau matériel).


Docker Origins : genèse du concept de conteneur

Les conteneurs mettent en œuvre un vieux concept d’isolation des processus permis par la philosophie Unix du “tout est fichier”.

chroot, jail, les 6 namespaces et les cgroups

chroot

  • Implémenté principalement par le programme chroot [change root : changer de racine], présent dans les systèmes UNIX depuis longtemps (1979 !) :

    “Comme tout est fichier, changer la racine d’un processus, c’est comme le faire changer de système”.

jail

  • jail est introduit par FreeBSD en 2002 pour compléter chroot et qui permet pour la première fois une isolation réelle (et sécurisée) des processus.

  • chroot ne s’occupait que de l’isolation d’un process par rapport au système de fichiers :

    • ce n’était pas suffisant, l’idée de “tout-est-fichier” possède en réalité plusieurs exceptions
    • un process chrooté n’est pas isolé du reste des process et peut agir de façon non contrôlée sur le système sur plusieurs aspects
  • En 2005, Sun introduit les conteneurs Solaris décrits comme un « chroot sous stéroïdes » : comme les jails de FreeBSD

Les namespaces (espaces de noms)

  • Les namespaces, un concept informatique pour parler simplement de…

    • groupes séparés auxquels on donne un nom, d’ensembles de choses sur lesquelles on colle une étiquette
    • on parle aussi de contextes
  • jail était une façon de compléter chroot, pour FreeBSD.

  • Pour Linux, ce concept est repris via la mise en place de namespaces Linux

    • Les namespaces sont inventés en 2002
    • popularisés lors de l’inclusion des 6 types de namespaces dans le noyau Linux (3.8) en 2013
  • Les conteneurs ne sont finalement que plein de fonctionnalités Linux saucissonnées ensemble de façon cohérente.

  • Les namespaces correspondent à autant de types de compartiments nécessaires dans l’architecture Linux pour isoler des processus.

Pour la culture, 6 types de namespaces :

  • Les namespaces PID : “fournit l’isolation pour l’allocation des identifiants de processus (PIDs), la liste des processus et de leurs détails. Tandis que le nouvel espace de nom est isolé de ses adjacents, les processus dans son espace de nommage « parent » voient toujours tous les processus dans les espaces de nommage enfants — quoique avec des numéros de PID différent.”
  • Network namespace : “isole le contrôleur de l’interface réseau (physique ou virtuel), les règles de pare-feu iptables, les tables de routage, etc.”
  • Mount namespace : “permet de créer différents modèles de systèmes de fichiers, ou de créer certains points de montage en lecture-seule”
  • User namespace : isolates the user IDs between namespaces (dernière pièce du puzzle)
  • “UTS” namespace : permet de changer le nom d’hôte.
  • IPC namespace : isole la communication inter-processus entre les espaces de nommage.

Les cgroups : derniers détails pour une vraie isolation

  • Après, il reste à s’occuper de limiter la capacité d’un conteneur à agir sur les ressources matérielles :

    • usage de la mémoire
    • du disque
    • du réseau
    • des appels système
    • du processeur (CPU)
  • En 2005, Google commence le développement des cgroups : une façon de tagger les demandes de processeur et les appels systèmes pour les grouper et les isoler.


Exemple : bloquer le système hôte depuis un simple conteneur

:(){ : | :& }; :

Ceci est une fork bomb. Dans un conteneur non privilégié, on bloque tout Docker, voire tout le système sous-jacent, en l’empêchant de créer de nouveaux processus.

Pour éviter cela il faudrait limiter la création de processus via une option kernel.

Ex: docker run -it --ulimit nproc=3 --name fork-bomb bash

L’isolation des conteneurs n’est donc ni magique, ni automatique, ni absolue ! Correctement paramétrée, elle est tout de même assez robuste, mature et testée.


Les conteneurs : définition

On revient à notre définition d’un conteneur :

Un conteneur est un groupe de processus associé à un ensemble de permissions sur le système.

1 container = 1 groupe de process Linux

  • des namespaces (séparation entre ces groups)
  • des cgroups (quota en ressources matérielles)

LXC (LinuX Containers)

  • En 2008 démarre le projet LXC qui chercher à rassembler :

    • les cgroups
    • le chroot
    • les namespaces.
  • Originellement, Docker était basé sur LXC. Il a depuis développé son propre assemblage de ces 3 mécanismes.


Docker et LXC

  • En 2013, Docker commence à proposer une meilleure finition et une interface simple qui facilite l’utilisation des conteneurs LXC.

  • Puis il propose aussi son cloud, le Docker Hub pour faciliter la gestion d’images toutes faites de conteneurs.

  • Au fur et à mesure, Docker abandonne le code de LXC (mais continue d’utiliser le chroot, les cgroups et namespaces).

  • Le code de base de Docker (notamment runC) est open source : l'Open Container Initiative vise à standardiser et rendre robuste l’utilisation de containers.


Bénéfices par rapport aux machines virtuelles

Docker permet de faire des “quasi-machines” avec des performances proches du natif.

  • Vitesse d’exécution.
  • Flexibilité sur les ressources (mémoire partagée).
  • Moins complexe que la virtualisation
  • Plus standard que les multiples hyperviseurs
    • notamment moins de bugs d’interaction entre l’hyperviseur et le noyau

Bénéfices par rapport aux machines virtuelles

VM et conteneurs proposent une flexibilité de manipulation des ressources de calcul mais les machines virtuelles sont trop lourdes pour être multipliées librement :

  • elles ne sont pas efficaces pour isoler chaque application
  • elles ne permettent pas la transformation profonde que permettent les conteneurs :
    • le passage à une architecture microservices
    • et donc la scalabilité pour les besoins des services cloud

Avantages des machines virtuelles

  • Les VM se rapprochent plus du concept de “boite noire”: l’isolation se fait au niveau du matériel et non au niveau du noyau de l’OS.

  • même si une faille dans l’hyperviseur reste possible car l’isolation n’est pas qu’uniquement matérielle

  • Les VM sont-elles “plus lentes” ? Pas forcément.

    • La RAM est-elle un facteur limite ? Non elle n’est pas cher
    • Les CPU pareil : on est rarement bloqués par la puissance du CPU
    • Le vrai problème c’est l’I/O : l’accès en entrée-sortie au disque et au réseau
      • en réalité Docker peut être plus lent (par défaut) pour l’implémentation de la sécurité réseau (usage du NAT), ou l’implémentation du réseau de Docker Swarm
      • pour l’accès au disque : la technologie d'overlay (qui a une place centrale dans Docker) s’améliore, surtout is on utilise un filesystem optimisé pour cela (ZFS, btrfs…).

La comparaison VM / conteneurs est un thème extrêmement vaste et complexe.


Pourquoi utiliser Docker ?

Docker est pensé dès le départ pour faire des conteneurs applicatifs :

  • isoler les modules applicatifs.

  • gérer les dépendances en les embarquant dans le conteneur.

  • se baser sur l'immutabilité : la configuration d’un conteneur n’est pas faite pour être modifiée après sa création.

  • avoir un cycle de vie court -> logique DevOps du “bétail vs. animal de compagnie”


Pourquoi utiliser Docker ?

Docker modifie beaucoup la “logistique” applicative.

  • uniformisation face aux divers langages de programmation, configurations et briques logicielles

  • installation sans accroc et automatisation beaucoup plus facile

  • permet de simplifier l'intégration continue, la livraison continue et le déploiement continu

  • rapproche le monde du développement des opérations (tout le monde utilise la même technologie)

  • Permet l’adoption plus large de la logique DevOps (notamment le concept d’infrastructure as code)


Infrastructure as Code

Résumé

  • on décrit en mode code un état du système. Avantages :
    • pas de dérive de la configuration et du système (immutabilité)
    • on peut connaître de façon fiable l’état des composants du système
    • on peut travailler en collaboration plus facilement (grâce à Git notamment)
    • on peut faire des tests
    • on facilite le déploiement de nouvelles instances

Docker : positionnement sur le marché

  • Docker est la technologie ultra-dominante sur le marché de la conteneurisation

    • La simplicité d’usage et le travail de standardisation (un conteneur Docker est un conteneur OCI : format ouvert standardisé par l’Open Container Initiative) lui garantissent légitimité et fiabilité
    • La logique du conteneur fonctionne, et la bonne documentation et l’écosystème aident !
  • LXC existe toujours et est très agréable à utiliser, notamment avec LXD (développé par Canonical, l’entreprise derrière Ubuntu).

    • Il a cependant un positionnement différent : faire des conteneurs pour faire tourner des OS Linux complets.
  • Apache Mesos : un logiciel de gestion de cluster qui permet de se passer de Docker, mais propose quand même un support pour les conteneurs OCI (Docker) depuis 2016.

  • Podman : une alternative à Docker qui utilise la même syntaxe que Docker pour faire tourner des conteneurs OCI (Docker) qui propose un mode rootless et daemonless intéressant.

  • systemd-nspawn : technologie de conteneurs isolés proposée par systemd


1 - Manipulation des conteneurs

Terminologie et concepts fondamentaux

Deux concepts centraux :

  • Une image : un modèle pour créer un conteneur
  • Un conteneur : l’instance qui tourne sur la machine.

Autres concepts primordiaux :

  • Un volume : un espace virtuel pour gérer le stockage d’un conteneur et le partage entre conteneurs.
  • un registry : un serveur ou stocker des artefacts docker c’est à dire des images versionnées.
  • un orchestrateur : un outil qui gère automatiquement le cycle de vie des conteneurs (création/suppression).

Visualiser l’architecture Docker

Daemon - Client - images - registry


L’écosystème Docker

  • Docker Compose : Un outil pour décrire des applications multiconteneurs.

  • Docker Machine : Un outil pour gérer le déploiement Docker sur plusieurs machines depuis un hôte.

  • Docker Hub : Le service d’hébergement d’images proposé par Docker Inc. (le registry officiel)


L’environnement de développement

  • Docker Engine pour lancer des commandes docker

  • Docker Compose pour lancer des application multiconteneurs

  • Portainer, un GUI Docker

  • VirtualBox pour avoir une VM Linux quand on est sur Windows


Installer Docker sur Windows ou MacOS

Docker est basé sur le noyau Linux :

  • En production il fonctionne nécessairement sur un Linux (virtualisé ou bare metal)
  • Pour développer et déployer, il marche parfaitement sur MacOS et Windows mais avec une méthode de virtualisation :
    • virtualisation optimisée via un hyperviseur
    • ou virtualisation avec logiciel de virtualisation “classique” comme VMWare ou VirtualBox.

Installer Docker sur Windows

Quatre possibilités :

  • Solution Docker Desktop WSL2 :

    • Fonctionne avec Windows Subsystem for Linux : c’est une VM Linux très bien intégrée à Windows

    • Le meilleur des deux mondes ?

    • Workflow similaire à celui d’un serveur Linux

  • Solution VirtualBox : on utilise Docker Engine dans une VM Linux

    • Utilise une VM Linux avec VirtualBox
    • Workflow identique à celui d’un serveur Linux
    • Proche de la réalité de l’administration système actuelle

Installer Docker sous MacOS

  • Solution standard : on utilise Docker Desktop for MacOS (fonctionne avec la bibliothèque HyperKit qui fait de l’hypervision)
  • Solution Virtualbox / legacy : On utilise une VM Linux

Installer Docker sur Linux

Pas de virtualisation nécessaire car Docker (le Docker Engine) utilise le noyau du système natif.

  • On peut l’installer avec le gestionnaire de paquets de l’OS mais cette version peut être trop ancienne.

  • Sur Ubuntu ou CentOS la méthode conseillée est d’utiliser les paquets fournis dans le dépôt officiel Docker (vous pouvez avoir des surprises avec la version snap d’Ubuntu).


Les images et conteneurs

Les images

Docker possède à la fois un module pour lancer les applications (runtime) et un outil de build d’application.

  • Une image est le résultat d’un build :
    • on peut la voir un peu comme une boîte “modèle” : on peut l’utiliser plusieurs fois comme base de création de containers identiques, similaires ou différents.

Pour lister les images on utilise :

docker images
docker image ls

Les conteneurs

  • Un conteneur est une instance en cours de fonctionnement (“vivante”) d’une image.
    • un conteneur en cours de fonctionnement est un processus (et ses processus enfants) qui tourne dans le Linux hôte (mais qui est isolé de celui-ci)

Commandes Docker

Docker fonctionne avec des sous-commandes et propose de grandes quantités d’options pour chaque commande.

Utilisez --help au maximum après chaque commande, sous-commande ou sous-sous-commandes

docker image --help

Pour vérifier l’état de Docker

  • Les commandes de base pour connaître l’état de Docker sont :
docker info  # affiche plein d'information sur l'engine avec lequel vous êtes en contact
docker ps    # affiche les conteneurs en train de tourner
docker ps -a # affiche  également les conteneurs arrêtés

Créer et lancer un conteneur

  • Un conteneur est une instance en cours de fonctionnement (“vivante”) d’une image.
docker run [-d] [-p port_h:port_c] [-v dossier_h:dossier_c] <image> <commande>

créé et lance le conteneur

  • L’ordre des arguments est important !
  • Un nom est automatiquement généré pour le conteneur à moins de fixer le nom avec --name
  • On peut facilement lancer autant d’instances que nécessaire tant qu’il n’y a pas de collision de nom ou de port.

Options docker run

  • Les options facultatives indiquées ici sont très courantes.
    • -d permet* de lancer le conteneur en mode daemon ou détaché et libérer le terminal
    • -p permet de mapper un port réseau entre l’intérieur et l’extérieur du conteneur, typiquement lorsqu’on veut accéder à l’application depuis l’hôte.
    • -v permet de monter un volume partagé entre l’hôte et le conteneur.
    • --rm (comme remove) permet de supprimer le conteneur dès qu’il s’arrête.
    • -it permet de lancer une commande en mode interactif (un terminal comme bash).
    • -a (ou --attach) permet de se connecter à l’entrée-sortie du processus dans le container.

Commandes Docker

  • Le démarrage d’un conteneur est lié à une commande.

  • Si le conteneur n’a pas de commande, il s’arrête dès qu’il a fini de démarrer

docker run debian # s'arrête tout de suite
  • Pour utiliser une commande on peut simplement l’ajouter à la fin de la commande run.
docker run debian echo 'attendre 10s' && sleep 10 # s'arrête après 10s

Stopper et redémarrer un conteneur

docker run créé un nouveau conteneur à chaque fois.

docker stop <nom_ou_id_conteneur> # ne détruit pas le conteneur
docker start <nom_ou_id_conteneur> # le conteneur a déjà été créé
docker start --attach <nom_ou_id_conteneur> # lance le conteneur et s'attache à la sortie standard

Isolation des conteneurs

  • Les conteneurs sont plus que des processus, ce sont des boîtes isolées grâce aux namespaces et cgroups

  • Depuis l’intérieur d’un conteneur, on a l’impression d’être dans un Linux autonome.

  • Plus précisément, un conteneur est lié à un système de fichiers (avec des dossiers /bin, /etc, /var, des exécutables, des fichiers…), et possède des métadonnées (stockées en json quelque part par Docker)

  • Les utilisateurs Unix à l’intérieur du conteneur ont des UID et GID qui existent classiquement sur l’hôte mais ils peuvent correspondre à un utilisateur Unix sans droits sur l’hôte si on utilise les user namespaces.


Introspection de conteneur

  • La commande docker exec permet d’exécuter une commande à l’intérieur du conteneur s’il est lancé.

  • Une utilisation typique est d’introspecter un conteneur en lançant bash (ou sh).

docker exec -it <conteneur> /bin/bash

Docker Hub : télécharger des images

Une des forces de Docker vient de la distribution d’images :

  • pas besoin de dépendances, on récupère une boîte autonome

  • pas besoin de multiples versions en fonction des OS

Dans ce contexte un élément qui a fait le succès de Docker est le Docker Hub : hub.docker.com

Il s’agit d’un répertoire public et souvent gratuit d’images (officielles ou non) pour des milliers d’applications pré-configurées.


Docker Hub:

  • On peut y chercher et trouver presque n’importe quel logiciel au format d’image Docker.

  • Il suffit pour cela de chercher l’identifiant et la version de l’image désirée.

  • Puis utiliser docker run [<compte>/]<id_image>:<version>

  • La partie compte est le compte de la personne qui a poussé ses images sur le Docker Hub. Les images Docker officielles (ubuntu par exemple) ne sont pas liées à un compte : on peut écrire simplement ubuntu:focal.

  • On peut aussi juste télécharger l’image : docker pull <image>

On peut également y créer un compte gratuit pour pousser et distribuer ses propres images, ou installer son propre serveur de distribution d’images privé ou public, appelé registry.


En résumé

TP 1 - Installer Docker et jouer avec

Premier TD : on installe Docker et on joue avec

Installer Docker sur la VM Ubuntu dans Guacamole
  • Pour installer Docker, suivez la documentation officielle pour installer Docker sur Ubuntu, depuis “Install using the repository” jusqu’aux deux commandes sudo apt-get update et sudo apt-get install docker-ce docker-ce-cli containerd.io.

    • Docker nous propose aussi une installation en une ligne (one-liner), moins sécurisée : curl -sSL https://get.docker.com | sudo sh
  • Lancez sudo docker run hello-world. Bien lire le message renvoyé (le traduire sur Deepl si nécessaire). Que s’est-il passé ?

  • Il manque les droits pour exécuter Docker sans passer par sudo à chaque fois.

    • Le daemon tourne toujours en root
    • Un utilisateur ne peut accéder au client que s’il est membre du groupe docker
    • Ajoutez-le au groupe avec la commande sudo usermod -aG docker $USER
    • Pour actualiser la liste de groupes auquel appartient l’utilisateur, redémarrez la VM avec sudo reboot puis reconnectez-vous avec Guacamole pour que la modification sur les groupes prenne effet.

Pour les prochaines fois, Docker nous propose aussi une installation en une ligne (one-liner) : curl -sSL https://get.docker.com | sudo sh

Autocomplétion

  • Pour vous faciliter la vie, ajoutez le plugin autocomplete pour Docker et Docker Compose à bash en copiant les commandes suivantes :
sudo apt update
sudo apt install bash-completion curl
sudo curl -L https://raw.githubusercontent.com/docker/compose/1.24.1/contrib/completion/bash/docker-compose -o /etc/bash_completion.d/docker-compose

Important: Vous pouvez désormais appuyer sur la touche pour utiliser l’autocomplétion quand vous écrivez des commandes Docker


Pour vérifier l’installation

  • Les commandes de base pour connaître l’état de Docker sont :
docker info  # affiche plein d'information sur l'engine avec lequel vous êtes en contact
docker ps    # affiche les conteneurs en train de tourner
docker ps -a # affiche  également les conteneurs arrêtés

Manipuler un conteneur

Mentalité : Il faut aussi prendre l’habitude de bien lire ce que la console indique après avoir passé vos commandes.

Avec l’aide du support et de --help, et en notant sur une feuille ou dans un fichier texte les commandes utilisées :

  • Lancez simplement un conteneur Debian. Que se passe-t-il ?
Résultat :
  • Lancez un conteneur Debian (docker run puis les arguments nécessaires, cf. l’aide --help)n avec l’option “mode détaché” et la commande passée au conteneur echo "Je suis le conteneur basé sur Debian". Rien n’apparaît. En effet en mode détaché la sortie standard n’est pas connectée au terminal.

  • Lancez docker logs avec le nom ou l’id du conteneur. Vous devriez voir le résultat de la commande echo précédente.

Résultat :
  • Affichez la liste des conteneurs en cours d’exécution
Solution :
  • Affichez la liste des conteneurs en cours d’exécution et arrêtés.
Solution :
  • Lancez un conteneur debian en mode détaché avec la commande sleep 3600

  • Réaffichez la liste des conteneurs qui tournent

  • Tentez de stopper le conteneur, que se passe-t-il ?

docker stop <conteneur>

NB: On peut désigner un conteneur soit par le nom qu’on lui a donné, soit par le nom généré automatiquement, soit par son empreinte (toutes ces informations sont indiquées dans un docker ps ou docker ps -a). L’autocomplétion fonctionne avec les deux noms.

  • Trouvez comment vous débarrasser d’un conteneur récalcitrant (si nécessaire, relancez un conteneur avec la commande sleep 3600 en mode détaché).
Solution :
  • Tentez de lancer deux conteneurs avec le nom debian_container
Solution :

Le nom d’un conteneur doit être unique (à ne pas confondre avec le nom de l’image qui est le modèle utilisé à partir duquel est créé le conteneur).

  • Créez un conteneur avec le nom debian2
docker run debian -d --name debian2 sleep 500
  • Lancez un conteneur debian en mode interactif (options -i -t) avec la commande /bin/bash et le nom debian_interactif.
  • Explorer l’intérieur du conteneur : il ressemble à un OS Linux Debian normal.

Chercher sur Docker Hub

  • Visitez hub.docker.com
  • Cherchez l’image de Nginx (un serveur web), et téléchargez la dernière version (pull).
docker pull nginx
  • Lancez un conteneur Nginx. Notez que lorsque l’image est déjà téléchargée le lancement d’un conteneur est quasi instantané.
docker run --name "test_nginx" nginx

Ce conteneur n’est pas très utile, car on a oublié de configurer un port exposé sur localhost.

  • Trouvez un moyen d’accéder quand même au Nginx à partir de l’hôte Docker (indice : quelle adresse IP le conteneur possède-t-il ?).
Solution :
  • Arrêtez le(s) conteneur(s) nginx créé(s).
  • Relancez un nouveau conteneur nginx avec cette fois-ci le port correctement configuré dès le début pour pouvoir visiter votre Nginx en local.
docker run -p 8080:80 --name "test2_nginx" nginx # la syntaxe est : port_hote:port_container
  • En visitant l’adresse et le port associé au conteneur Nginx, on doit voir apparaître des logs Nginx dans son terminal car on a lancé le conteneur en mode attach.
  • Supprimez ce conteneur. NB : On doit arrêter un conteneur avant de le supprimer, sauf si on utilise l’option “-f”.

On peut lancer des logiciels plus ambitieux, comme par exemple Funkwhale, une sorte d’iTunes en web qui fait aussi réseau social :

docker run --name funky_conteneur -p 80:80 funkwhale/all-in-one:1.0.1

Vous pouvez visiter ensuite ce conteneur Funkwhale sur le port 80 (après quelques secondes à suivre le lancement de l’application dans les logs) ! Mais il n’y aura hélas pas de musique dedans :(

Attention à ne jamais lancer deux containers connectés au même port sur l’hôte, sinon cela échouera !

  • Supprimons ce conteneur :
docker rm -f funky_conteneur

Facultatif : Wordpress, MYSQL et les variables d’environnement

  • Lancez un conteneur Wordpress joignable sur le port 8080 à partir de l’image officielle de Wordpress du Docker Hub
  • Visitez ce Wordpress dans le navigateur

Nous pouvons accéder au Wordpress, mais il n’a pas encore de base MySQL configurée. Ce serait un peu dommage de configurer cette base de données à la main. Nous allons configurer cela à partir de variables d’environnement et d’un deuxième conteneur créé à partir de l’image mysql.

Depuis Ubuntu:

  • Il va falloir mettre ces deux conteneurs dans le même réseau (nous verrons plus tarde ce que cela implique), créons ce réseau :
docker network create wordpress
  • Cherchez le conteneur mysql version 5.7 sur le Docker Hub.

  • Utilisons des variables d’environnement pour préciser le mot de passe root, le nom de la base de données et le nom d’utilisateur de la base de données (trouver la documentation sur le Docker Hub).

  • Il va aussi falloir définir un nom pour ce conteneur

Résultat :
  • inspectez le conteneur MySQL avec docker inspect

  • Faites de même avec la documentation sur le Docker Hub pour préconfigurer l’app Wordpress.

  • En plus des variables d’environnement, il va falloir le mettre dans le même réseau, et exposer un port

Solution :
  • regardez les logs du conteneur Wordpress avec docker logs

  • visitez votre app Wordpress et terminez la configuration de l’application : si les deux conteneurs sont bien configurés, on ne devrait pas avoir à configurer la connexion à la base de données

Faire du ménage

Il est temps de faire un petit docker stats pour découvrir l’utilisation du CPU et de la RAM de vos conteneurs !

  • Lancez la commande docker ps -aq -f status=exited. Que fait-elle ?

  • Combinez cette commande avec docker rm pour supprimer tous les conteneurs arrêtés (indice : en Bash, une commande entre les parenthèses de “$()” est exécutée avant et utilisée comme chaîne de caractère dans la commande principale)

Solution :
  • S’il y a encore des conteneurs qui tournent (docker ps), supprimez un des conteneurs restants en utilisant l’autocomplétion et l’option adéquate

  • Listez les images

  • Supprimez une image

  • Que fait la commande docker image prune -a ?

Décortiquer un conteneur

  • En utilisant la commande docker export votre_conteneur -o conteneur.tar, puis tar -C conteneur_decompresse -xvf conteneur.tar pour décompresser un conteneur Docker, explorez (avec l’explorateur de fichiers par exemple) jusqu’à trouver l’exécutable principal contenu dans le conteneur.

Portainer

Portainer est un portail web pour gérer une installation Docker via une interface graphique. Il va nous faciliter la vie.

  • Lancer une instance de Portainer :
docker volume create portainer_data
docker run --detach --name portainer -p 9000:9000 -v portainer_data:/data -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer-ce
  • Remarque sur la commande précédente : pour que Portainer puisse fonctionner et contrôler Docker lui-même depuis l’intérieur du conteneur il est nécessaire de lui donner accès au socket de l’API Docker de l’hôte grâce au paramètre --volume ci-dessus.

  • Visitez ensuite la page http://localhost:9000 ou l’adresse IP publique de votre serveur Docker sur le port 9000 pour accéder à l’interface.

  • il faut choisir l’option “local” lors de la configuration

  • Créez votre user admin et choisir un mot de passe avec le formulaire.

  • Explorez l’interface de Portainer.

  • Créez un conteneur.

2 - Images et conteneurs

Créer une image en utilisant un Dockerfile

  • Jusqu’ici nous avons utilisé des images toutes prêtes.

  • Une des fonctionnalités principales de Docker est de pouvoir facilement construire des images à partir d’un simple fichier texte : le Dockerfile.

Le processus de build Docker

  • Un image Docker ressemble un peu à une VM car on peut penser à un Linux “freezé” dans un état.

  • En réalité c’est assez différent : il s’agit uniquement d’un système de fichier (par couches ou layers) et d’un manifeste JSON (des méta-données).

  • Les images sont créés en empilant de nouvelles couches sur une image existante grâce à un système de fichiers qui fait du union mount.


  • Chaque nouveau build génère une nouvelle image dans le répertoire des images (/var/lib/docker/images) (attention ça peut vite prendre énormément de place)

  • On construit les images à partir d’un fichier Dockerfile en décrivant procéduralement (étape par étape) la construction.

Exemple de Dockerfile :

FROM debian:latest

RUN apt update && apt install -y htop

CMD ['sleep 1000']
  • La commande pour construire l’image est :
docker build [-t tag] [-f dockerfile] <build_context>
  • généralement pour construire une image on se place directement dans le dossier avec le Dockerfile et les élements de contexte nécessaire (programme, config, etc), le contexte est donc le caractère ., il est obligatoire de préciser un contexte.

  • exemple : docker build -t mondebian .


  • Le Dockerfile est un fichier procédural qui permet de décrire l’installation d’un logiciel (la configuration d’un container) en enchaînant des instructions Dockerfile (en MAJUSCULE).

  • Exemple:

# our base image
FROM alpine:3.5

# Install python and pip
RUN apk add --update py2-pip

# upgrade pip
RUN pip install --upgrade pip

# install Python modules needed by the Python app
COPY requirements.txt /usr/src/app/
RUN pip install --no-cache-dir -r /usr/src/app/requirements.txt

# copy files required for the app to run
COPY app.py /usr/src/app/
COPY templates/index.html /usr/src/app/templates/

# tell the port number the container should expose
EXPOSE 5000

# run the application
CMD ["python", "/usr/src/app/app.py"]

Instruction FROM

  • L’image de base à partir de laquelle est construite l’image actuelle.

Instruction RUN

  • Permet de lancer une commande shell (installation, configuration).

Instruction ADD ou COPY

  • Permet d’ajouter des fichier depuis le contexte de build à l’intérieur du conteneur.
  • Généralement utilisé pour ajouter le code du logiciel en cours de développement et sa configuration au conteneur.
  • Ces deux instructions ont des petites différences subtiles : les options de COPY sont plus complètes, et ADD permet de télécharger et dézipper un fichier disponible à une URL distante.

Instruction CMD

  • Généralement à la fin du Dockerfile : elle permet de préciser la commande par défaut lancée à la création d’une instance du conteneur avec docker run. on l’utilise avec une liste de paramètres
CMD ["echo 'Conteneur démarré'"]

Instruction ENTRYPOINT

  • Précise le programme de base avec lequel sera lancé la commande
ENTRYPOINT ["/usr/bin/python3"]

CMD et ENTRYPOINT

  • Ne surtout pas confondre avec RUN qui exécute une commande Bash uniquement pendant la construction de l’image.

L’instruction CMD a trois formes :

  • CMD ["executable","param1","param2"] (exec form, forme à préférer)
  • CMD ["param1","param2"] (combinée à une instruction ENTRYPOINT)
  • CMD command param1 param2 (shell form)

Si l’on souhaite que notre container lance le même exécutable à chaque fois, alors on peut opter pour l’usage d'ENTRYPOINT en combination avec CMD.


Instruction ENV

  • Une façon recommandée de configurer vos applications Docker est d’utiliser les variables d’environnement UNIX, ce qui permet une configuration “au runtime”.

Instruction HEALTHCHECK

HEALTHCHECK permet de vérifier si l’app contenue dans un conteneur est en bonne santé.

HEALTHCHECK CMD curl --fail http://localhost:5000/health

Les variables

On peut utiliser des variables d’environnement dans les Dockerfiles. La syntaxe est ${...}. Exemple :

FROM busybox
ENV FOO=/bar
WORKDIR ${FOO}   # WORKDIR /bar
ADD . $FOO       # ADD . /bar
COPY \$FOO /quux # COPY $FOO /quux

Se référer au mode d’emploi pour la logique plus précise de fonctionnement des variables.

Documentation


Lancer la construction

  • La commande pour lancer la construction d’une image est :
docker build [-t <tag:version>] [-f <chemin_du_dockerfile>] <contexte_de_construction>
  • Lors de la construction, Docker télécharge l’image de base. On constate plusieurs téléchargements en parallèle.

  • Il lance ensuite la séquence des instructions du Dockerfile.

  • Observez l’historique de construction de l’image avec docker image history <image>

  • Il lance ensuite la série d’instructions du Dockerfile et indique un hash pour chaque étape.

    • C’est le hash correspondant à un layer de l’image

Les layers et la mise en cache

  • Docker construit les images comme une série de “couches” de fichiers successives.

  • On parle d'Union Filesystem car chaque couche (de fichiers) écrase la précédente.

  • Chaque couche correspond à une instruction du Dockerfile.

  • docker image history <conteneur> permet d’afficher les layers, leur date de construction et taille respectives.

  • Ce principe est au coeur de l'immutabilité des images Docker.

  • Au lancement d’un container, le Docker Engine rajoute une nouvelle couche de filesystem “normal” read/write par dessus la pile des couches de l’image.

  • docker diff <container> permet d’observer les changements apportés au conteneur depuis le lancement.


Optimiser la création d’images

  • Les images Docker ont souvent une taille de plusieurs centaines de mégaoctets voire parfois gigaoctets. docker image ls permet de voir la taille des images.

  • Or, on construit souvent plusieurs dizaines de versions d’une application par jour (souvent automatiquement sur les serveurs d’intégration continue).

    • L’espace disque devient alors un sérieux problème.
  • Le principe de Docker est justement d’avoir des images légères car on va créer beaucoup de conteneurs (un par instance d’application/service).

  • De plus on télécharge souvent les images depuis un registry, ce qui consomme de la bande passante.

La principale bonne pratique dans la construction d’images est de limiter leur taille au maximum.


Limiter la taille d’une image

  • Choisir une image Linux de base minimale:

    • Une image ubuntu complète pèse déjà presque une soixantaine de mégaoctets.
    • mais une image trop rudimentaire (busybox) est difficile à débugger et peu bloquer pour certaines tâches à cause de binaires ou de bibliothèques logicielles qui manquent (compilation par exemple).
    • Souvent on utilise des images de base construites à partir de alpine qui est un bon compromis (6 mégaoctets seulement et un gestionnaire de paquets apk).
    • Par exemple python3 est fourni en version python:alpine (99 Mo), python:3-slim (179 Mo) et python:latest (918 Mo).

Les multi-stage builds

Quand on tente de réduire la taille d’une image, on a recours à un tas de techniques. Avant, on utilisait deux Dockerfile différents : un pour la version prod, léger, et un pour la version dev, avec des outils en plus. Ce n’était pas idéal. Par ailleurs, il existe une limite du nombre de couches maximum par image (42 layers). Souvent on enchaînait les commandes en une seule pour économiser des couches (souvent, les commandes RUN et ADD), en y perdant en lisibilité.

Maintenant on peut utiliser les multistage builds.

Avec les multi-stage builds, on peut utiliser plusieurs instructions FROM dans un Dockerfile. Chaque instruction FROM utilise une base différente. On sélectionne ensuite les fichiers intéressants (des fichiers compilés par exemple) en les copiant d’un stage à un autre.

Exemple de Dockerfile utilisant un multi-stage build :

FROM golang:1.7.3 AS builder
WORKDIR /go/src/github.com/alexellis/href-counter/
RUN go get -d -v golang.org/x/net/html
COPY app.go .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /go/src/github.com/alexellis/href-counter/app .
CMD ["./app"]

Créer des conteneurs personnalisés

  • Il n’est pas nécessaire de partir d’une image Linux vierge pour construire un conteneur.

  • On peut utiliser la directive FROM avec n’importe quelle image.

  • De nombreuses applications peuvent être configurées en étendant une image officielle

  • Exemple : une image Wordpress déjà adaptée à des besoins spécifiques.

  • L’intérêt ensuite est que l’image est disponible préconfigurée pour construire ou mettre à jour une infrastructure, ou lancer plusieurs instances (plusieurs containers) à partir de cette image.

  • C’est grâce à cette fonctionnalité que Docker peut être considéré comme un outil d'infrastructure as code.

  • On peut également prendre une sorte de snapshot du conteneur (de son système de fichiers, pas des processus en train de tourner) sous forme d’image avec docker commit <image> et docker push.


Publier des images vers un registry privé

  • Généralement les images spécifiques produites par une entreprise n’ont pas vocation à finir dans un dépôt public.

  • On peut installer des registries privés.

  • On utilise alors docker login <adresse_repo> pour se logger au registry et le nom du registry dans les tags de l’image.

  • Exemples de registries :

    • Gitlab fournit un registry très intéressant car intégré dans leur workflow DevOps.

Le design pattern de l’architecture “microservice” (multi-conteneurs) : 12factor.net

12factor.net

  • faire en sorte que le conteneur soit agnostique de l’environnement :
    • s’assure qu’il a les services dont il a besoin
    • config dans des volumes ou des variables d’environnement
    • le plus “stateless” possible
    • interagit avec d’autres services via des ports réseau
    • log bien via son process principal
    • se lance vite et s’éteint proprement rapidement
    • basé sur la même image pour la prod et le dev (ou au mieux)

TP 2a - Images et Dockerfile

Découverte d’une application web flask

  • Récupérez d’abord une application Flask exemple en la clonant :
git clone https://github.com/uptime-formation/microblog/
  • Si VSCode n’est pas installé : sudo snap install --classic code

  • Ouvrez VSCode avec le dossier microblog en tapant code microblog ou bien en lançant VSCode avec code puis en cliquant sur Open Folder.

  • Dans VSCode, vous pouvez faire Terminal > New Terminal pour obtenir un terminal en bas de l’écran.

  • Observons ensemble le code dans VSCode.

Passons à Docker

Déployer une application Flask manuellement à chaque fois est relativement pénible. Pour que les dépendances de deux projets Python ne se perturbent pas, il faut normalement utiliser un environnement virtuel virtualenv pour séparer ces deux apps. Avec Docker, les projets sont déjà isolés dans des conteneurs. Nous allons donc construire une image de conteneur pour empaqueter l’application et la manipuler plus facilement. Assurez-vous que Docker est installé.

Pour connaître la liste des instructions des Dockerfiles et leur usage, se référer au manuel de référence sur les Dockerfiles.

  • Dans le dossier du projet ajoutez un fichier nommé Dockerfile et sauvegardez-le

  • Normalement, VSCode vous propose d’ajouter l’extension Docker. Il va nous faciliter la vie, installez-le. Une nouvelle icône apparaît dans la barre latérale de gauche, vous pouvez y voir les images téléchargées et les conteneurs existants. L’extension ajoute aussi des informations utiles aux instructions Dockerfile quand vous survolez un mot-clé avec la souris.

  • Ajoutez en haut du fichier : FROM python:3.9 Cette commande indique que notre image de base est la version 3.9 de Python. Quel OS est utilisé ? Vérifier en examinant l’image ou via le Docker Hub.

  • Nous pouvons déjà contruire un conteneur à partir de ce modèle Ubuntu vide : docker build -t microblog .

  • Une fois la construction terminée lancez le conteneur.

  • Le conteneur s’arrête immédiatement. En effet il ne contient aucune commande bloquante et nous n’avons précisé aucune commande au lancement.

Il s’agit d’un Linux standard, mais il n’est pas conçu pour être utilisé comme un système complet, juste pour une application isolée. Il faut maintenant ajouter notre application Flask à l’intérieur.

  • Pour installer les dépendances python et configurer la variable d’environnement Flask, il va falloir :
    • ajouter le fichier requirements.txt avec COPY
    • lancer pip3 install -r requirements.txt
    • initialiser la variable d’environnement FLASK_APP à microblog.py
Solution :
  • Reconstruisez votre image. Si tout se passe bien, poursuivez.

  • Ensuite, copions le code de l’application à l’intérieur du conteneur.

Solution :

Cette ligne indique de copier tout le contenu du dossier courant sur l’hôte dans un dossier /microblog à l’intérieur du conteneur. Nous n’avons pas copié les requirements en même temps pour pouvoir tirer partie des fonctionnalités de cache de Docker, et ne pas avoir à retélécharger les dépendances de l’application à chaque fois que l’on modifie le contenu de l’app.

Puis, faites que le dossier courant dans le conteneur est déplacé à /microblog.

Solution :
  • Reconstruisez votre image. Observons que le build recommence à partir de l’instruction modifiée. Les layers précédents avaient été mis en cache par le Docker Engine.

  • Si tout se passe bien, poursuivez.

  • Enfin, ajoutons la section de démarrage à la fin du Dockerfile, c’est un script appelé boot.sh :

Solution :
  • Reconstruisez l’image et lancez un conteneur basé sur l’image en ouvrant le port 5000 avec la commande : docker run -p 5000:5000 microblog

  • Naviguez dans le navigateur à l’adresse localhost:5000 pour admirer le prototype microblog.

  • Lancez un deuxième container cette fois avec : docker run -d -p 5001:5000 microblog

  • Une deuxième instance de l’app est maintenant en fonctionnement et accessible à l’adresse localhost:5001

Améliorer le Dockerfile

Une image plus simple

  • A l’aide de l’image python:3.9-alpine et en remplaçant les instructions nécessaires, repackagez l’app microblog en une image taggée microblog:slim ou microblog:light. Comparez la taille entre les deux images ainsi construites.

Ne pas faire tourner l’app en root

Solution :

Construire l’application avec docker build, la lancer et vérifier avec docker exec, whoami et id l’utilisateur avec lequel tourne le conteneur.

Réponse :

Documenter les ports utilisés

  • Ajoutons l’instruction EXPOSE 5000 pour indiquer à Docker que cette app est censée être accédée via son port 5000.
  • NB : Publier le port grâce à l’option -p port_de_l-hote:port_du_container reste nécessaire, l’instruction EXPOSE n’est là qu’à titre de documentation de l’image.

Faire varier la configuration en fonction de l’environnement

Le serveur de développement Flask est bien pratique pour debugger en situation de développement, mais n’est pas adapté à la production. Nous pourrions créer deux images pour les deux situations mais ce serait aller contre l’impératif DevOps de rapprochement du dev et de la prod.

Pour démarrer l’application, nous avons fait appel à un script de boot boot.sh avec à l’intérieur :

#!/bin/bash

# ...

set -e
if [ "$CONTEXT" = 'DEV' ]; then
    echo "Running Development Server"
    FLASK_ENV=development exec flask run -h 0.0.0.0
else
    echo "Running Production Server"
    exec gunicorn -b :5000 --access-logfile - --error-logfile - app_name:app
fi
  • Déclarez maintenant dans le Dockerfile la variable d’environnement CONTEXT avec comme valeur par défaut PROD.

  • Construisez l’image avec build.

  • Puis, grâce aux bons arguments allant avec docker run, lancez une instance de l’app en configuration PROD et une instance en environnement DEV (joignables sur deux ports différents).

  • Avec docker ps ou en lisant les logs, vérifiez qu’il existe bien une différence dans le programme lancé.

Dockerfile amélioré

`Dockerfile` final :

TP 2b - Exercices sur les images

Portainer :

Docker Hub

  • Avec docker login, docker tag et docker push, poussez l’image microblog sur le Docker Hub. Créez un compte sur le Docker Hub le cas échéant.
Solution :

L’instruction HEALTHCHECK

HEALTHCHECK permet de vérifier si l’app contenue dans un conteneur est en bonne santé.

  • Dans un nouveau dossier ou répertoire, créez un fichier Dockerfile dont le contenu est le suivant :
FROM python:alpine

RUN apk add curl
RUN pip install flask

ADD /app.py /app/app.py
WORKDIR /app
EXPOSE 5000

HEALTHCHECK CMD curl --fail http://localhost:5000/health

CMD python app.py
  • Créez aussi un fichier app.py avec ce contenu :
from flask import Flask

healthy = True

app = Flask(__name__)

@app.route('/health')
def health():
    global healthy

    if healthy:
        return 'OK', 200
    else:
        return 'NOT OK', 500

@app.route('/kill')
def kill():
    global healthy
    healthy = False
    return 'You have killed your app.', 200


if __name__ == "__main__":
    app.run(host="0.0.0.0")
  • Observez bien le code Python et la ligne HEALTHCHECK du Dockerfile puis lancez l’app. A l’aide de docker ps, relevez où Docker indique la santé de votre app.

  • Visitez l’URL /kill de votre app dans un navigateur. Refaites docker ps. Que s’est-il passé ?

  • (Facultatif) Rajoutez une instruction HEALTHCHECK au Dockerfile de notre app microblog.


Facultatif : construire une image “à la main”

Avec docker commit, trouvons comment ajouter une couche à une image existante. La commande docker diff peut aussi être utile.

Solution :

Facultatif : Décortiquer une image

Une image est composée de plusieurs layers empilés entre eux par le Docker Engine et de métadonnées.

  • Affichez la liste des images présentes dans votre Docker Engine.

  • Inspectez la dernière image que vous venez de créez (docker image --help pour trouver la commande)

  • Observez l’historique de construction de l’image avec docker image history <image>

  • Visitons en root (sudo su) le dossier /var/lib/docker/ sur l’hôte. En particulier, image/overlay2/layerdb/sha256/ :

    • On y trouve une sorte de base de données de tous les layers d’images avec leurs ancêtres.
    • Il s’agit d’une arborescence.
  • Vous pouvez aussi utiliser la commande docker save votre_image -o image.tar, et utiliser tar -C image_decompressee/ -xvf image.tar pour décompresser une image Docker puis explorer les différents layers de l’image.

  • Pour explorer la hiérarchie des images vous pouvez installer https://github.com/wagoodman/dive


Facultatif : un Registry privé

  • En récupérant la commande indiquée dans la doc officielle, créez votre propre registry.
  • Puis trouvez comment y pousser une image dessus.
  • Enfin, supprimez votre image en local et récupérez-la depuis votre registry.
Solution :

Facultatif : Faire parler la vache

Créons un nouveau Dockerfile qui permet de faire dire des choses à une vache grâce à la commande cowsay. Le but est de faire fonctionner notre programme dans un conteneur à partir de commandes de type :

  • docker run --rm cowsay Coucou !

  • docker run --rm cowsay doit afficher une vache qui dit “Hello”

  • docker run --rm cowsay -f stegosaurus Yo!

  • docker run --rm cowsay -f elephant-in-snake Un éléphant dans un boa.

  • Doit-on utiliser la commande ENTRYPOINT ou la commande CMD ? Se référer au manuel de référence sur les Dockerfiles si besoin.

  • Pour information, cowsay s’installe dans /usr/games/cowsay.

  • La liste des options (incontournables) de cowsay se trouve ici : https://debian-facile.org/doc:jeux:cowsay

Solution :
  • L’instruction ENTRYPOINT et la gestion des entrées-sorties des programmes dans les Dockerfiles peut être un peu capricieuse et il faut parfois avoir de bonnes notions de Bash et de Linux pour comprendre (et bien lire la documentation Docker).
  • On utilise parfois des conteneurs juste pour qu’ils s’exécutent une fois (pour récupérer le résultat dans la console, ou générer des fichiers). On utilise alors l’option --rm pour les supprimer dès qu’ils s’arrêtent.

Facultatif : TP avancé : Un multi-stage build avec distroless comme image de base de prod

Chercher la documentation sur les images distroless. Quel est l’intérêt ? Quels sont les cas d’usage ?

Objectif : transformer le Dockerfile de l’app nodejs (express) suivante en build multistage : https://github.com/Uptime-Formation/docker-example-nodejs-multistage-distroless.git Le builder sera par exemple basé sur l’image node:20 et le résultat sur gcr.io/distroless/nodejs20-debian11.

La doc:

Deux exemples simple pour vous aider:

Une correction possible dans la branche correction : git clone https://github.com/Uptime-Formation/docker-example-nodejs-multistage-distroless/ -b correction

L’image résultante fait tout de même environ 170Mo.

Pour entrer dans les détails de l’image on peut installer et utiliser https://github.com/wagoodman/dive

3 - Volumes et réseaux

Cycle de vie d’un conteneur

  • Un conteneur a un cycle de vie très court: il doit pouvoir être créé et supprimé rapidement même en contexte de production.

Conséquences :

  • On a besoin de mécanismes d’autoconfiguration, en particuler réseau car les IP des différents conteneur changent tout le temps.
  • On ne peut pas garder les données persistantes dans le conteneur.

Solutions :

  • Des réseaux dynamiques par défaut automatiques (DHCP mais surtout DNS automatiques)
  • Des volumes (partagés ou non, distribués ou non) montés dans les conteneurs

Réseau

Gestion des ports réseaux (port mapping)

  • L’instruction EXPOSE dans le Dockerfile informe Docker que le conteneur écoute sur les ports réseau au lancement. L’instruction EXPOSE ne publie pas les ports. C’est une sorte de documentation entre la personne qui construit les images et la personne qui lance le conteneur à propos des ports que l’on souhaite publier.

  • Par défaut les conteneurs n’ouvrent donc pas de port même s’ils sont déclarés avec EXPOSE dans le Dockerfile.

  • Pour publier un port au lancement d’un conteneur, c’est l’option -p <port_host>:<port_guest> de docker run.

  • Instruction port: d’un compose file.


Bridge et overlay

  • Un réseau bridge est une façon de créer un pont entre deux carte réseaux pour construire un réseau à partir de deux.

  • Par défaut les réseaux docker fonctionne en bridge (le réseau de chaque conteneur est bridgé à un réseau virtuel docker)

  • par défaut les adresses sont en 172.0.0.0/8, typiquement chaque hôte définit le bloc d’IP 172.17.0.0/16 configuré avec DHCP.

  • Un réseau overlay est un réseau virtuel privé déployé par dessus un réseau existant (typiquement public). Pour par exemple faire un cloud multi-datacenters.

Le réseau Docker est très automatique

  • Serveur DNS et DHCP intégré dans le “user-defined network” (c’est une solution IPAM)

  • Donne un nom de domaine automatique à chaque conteneur.

  • Mais ne pas avoir peur d’aller voir comment on perçoit le réseau de l’intérieur. Nécessaire pour bien contrôler le réseau.

  • ingress : un loadbalancer automatiquement connecté aux nœuds d’un Swarm. Voir la doc sur les réseaux overlay.

Lier des conteneurs

  • Aujourd’hui il faut utiliser un réseau dédié créé par l’utilisateur (“user-defined bridge network”)

    • avec l’option --network de docker run
    • avec l’instruction networks: dans un docker composer
  • On peut aussi créer un lien entre des conteneurs

    • avec l’option --link de docker run
    • avec l’instruction link: dans un docker composer
    • MAIS cette fonctionnalité est obsolète et déconseillée

Plugins réseaux

Il existe :

  • les réseaux par défaut de Docker
  • plusieurs autres solutions spécifiques de réseau disponibles pour des questions de performance et de sécurité
    • Ex. : Weave Net pour un cluster Docker Swarm
      • fournit une autoconfiguration très simple
      • de la sécurité
      • un DNS qui permet de simuler de la découverte de service
      • Du multicast UDP

Volumes

Les volumes Docker via la sous-commande volume

  • docker volume ls
  • docker volume inspect
  • docker volume prune
  • docker volume create
  • docker volume rm

Bind mounting

Lorsqu’un répertoire hôte spécifique est utilisé dans un volume (la syntaxe -v HOST_DIR:CONTAINER_DIR), elle est souvent appelée bind mounting (“montage lié”). C’est quelque peu trompeur, car tous les volumes sont techniquement “bind mounted”. La particularité, c’est que le point de montage sur l’hôte est explicite plutôt que caché dans un répertoire appartenant à Docker.

Exemple :

# Sur l'hôte
docker run -it -v /home/user/app/config.conf:/config/main.conf:ro -v /home/user/app/data:/data ubuntu /bin/bash

# Dans le conteneur
cd /data/
touch testfile
exit

# Sur l'hôte
ls /home/user/app/data:

Volumes nommés

  • L’autre technique est de créer d’abord un volume nommé avec : docker volume create mon_volume docker run -d -v mon_volume:/data redis

L’instruction VOLUME dans un Dockerfile

L’instruction VOLUME dans un Dockerfile permet de désigner les volumes qui devront être créés lors du lancement du conteneur. On précise ensuite avec l’option -v de docker run à quoi connecter ces volumes. Si on ne le précise pas, Docker crée quand même un volume Docker au nom généré aléatoirement, un volume “caché”.

Partager des données avec un volume

  • Pour partager des données on peut monter le même volume dans plusieurs conteneurs.

  • Pour lancer un conteneur avec les volumes d’un autre conteneur déjà montés on peut utiliser --volumes-from <container>

  • On peut aussi créer le volume à l’avance et l’attacher après coup à un conteneur.

  • Par défaut le driver de volume est local c’est-à-dire qu’un dossier est créé sur le disque de l’hôte.

docker volume create --driver local \
    --opt type=btrfs \
    --opt device=/dev/sda2 \
    monVolume

Plugins de volumes

On peut utiliser d’autres systèmes de stockage en installant de nouveau plugins de driver de volume. Par exemple, le plugin vieux/sshfs permet de piloter un volume distant via SSH.

Exemples:

  • SSHFS (utilisation d’un dossier distant via SSH)
  • NFS (protocole NFS)
  • BeeGFS (système de fichier distribué générique)
  • Amazon EBS (vendor specific)
  • etc.
docker volume create -d vieux/sshfs -o sshcmd=<sshcmd> -o allow_other sshvolume
docker run -p 8080:8080 -v sshvolume:/path/to/folder --name test someimage

Ou via docker-compose :

volumes:
  sshfsdata:
    driver: vieux/sshfs:latest
    driver_opts:
      sshcmd: "username@server:/location/on/the/server"
      allow_other: ""

Permissions

  • Un volume est créé avec les permissions du dossier préexistant.
FROM debian
RUN groupadd -r graphite && useradd -r -g graphite graphite
RUN mkdir -p /data/graphite && chown -R graphite:graphite /data/graphite
VOLUME /data/graphite
USER graphite
CMD ["echo", "Data container for graphite"]

Backups de volumes

  • Pour effectuer un backup la méthode recommandée est d’utiliser un conteneur suplémentaire dédié
  • qui accède au volume avec --volume-from
  • qui est identique aux autres et donc normalement avec les mêmes UID/GID/permissions.

TP 3a - Réseaux

Portainer

Partie 1 : Docker networking

Récupérons les images depuis Docker Hub:

  • docker image pull redis:alpine

  • docker image pull russmckendrick/moby-counter

  • Lancez la commande ip -br a pour lister vos interfaces réseau

Pour connecter les deux applications créons un réseau manuellement:

  • docker network create moby-network

Docker implémente ces réseaux virtuels en créant des interfaces. Lancez la commande ip -br a de nouveau et comparez. Qu’est-ce qui a changé ?

Maintenant, lançons les deux applications en utilisant notre réseau :

  • docker run -d --name redis --network <réseau> redis:alpine

  • docker run -d --name moby-counter --network <réseau> -p 80:80 russmckendrick/moby-counter

  • Visitez la page de notre application. Qu’en pensez vous ? Moby est le nom de la mascotte Docker 🐳 😊. Faites un motif en cliquant.

Comment notre application se connecte-t-elle au conteneur redis ? Elle utilise ces instructions JS dans son fichier server.js:

var port = opts.redis_port || process.env.USE_REDIS_PORT || 6379;
var host = opts.redis_host || process.env.USE_REDIS_HOST || "redis";

En résumé par défaut, notre application se connecte sur l’hôte redis avec le port 6379

Explorons un peu notre réseau Docker.

  • Exécutez (docker exec) la commande ping -c 3 redis à l’intérieur de notre conteneur applicatif (moby-counter donc). Quelle est l’adresse IP affichée ?
docker exec moby-counter ping -c3 redis
  • Qu’est-ce que Docker fournit qui permet que ce ping fonctionne ?

  • Pour s’en assurer, interrogeons le serveur DNS de notre réseau moby-network en lançant la commande nslookup redis grâce à docker exec : docker exec moby-counter nslookup redis

  • Créez un deuxième réseau moby-network2

  • Créez une deuxième instance de l’application dans ce réseau : docker run -d --name moby-counter2 --network moby-network2 -p 9090:80 russmckendrick/moby-counter

  • Lorsque vous pingez redis depuis cette nouvelle instance moby-counter2, qu’obtenez-vous ? Pourquoi ?

  • Comment peut-on faire que moby-counter2 joigne un deuxième Redis ?

    • il y a deux solutions possibles

Une deuxième stack moby-counter

Vous ne pouvez pas avoir deux conteneurs avec les mêmes noms, comme nous l’avons déjà découvert. Par contre, notre deuxième réseau fonctionne complètement isolé de notre premier réseau, ce qui signifie que nous pouvons toujours utiliser le nom de domaine redis. Pour ce faire, nous devons spécifier l’option --network-alias :

  • Créons un deuxième redis avec le même domaine: docker run -d --name redis2 --network moby-network2 --network-alias redis redis:alpine

  • Lorsque vous pingez redis depuis cette nouvelle instance de l’application, quelle IP obtenez-vous ?

  • Lancez nslookup redis dans le conteneur moby-counter2 pour tester la résolution de DNS.

  • Vous pouvez retrouver la configuration du réseau et les conteneurs qui lui sont reliés avec docker network inspect moby-network2. Notez la section IPAM (IP Address Management).

  • Arrêtons nos conteneurs : docker stop moby-counter2 redis2.


TP 3b - Volumes

Portainer

Partie 2 : Volumes Docker

Introduction aux volumes

  • Pour comprendre ce qu’est un volume, lançons un conteneur en mode interactif et associons-y le dossier /tmp/dossier-hote de l’hôte au dossier /dossier-conteneur sur le conteneur :
docker run -it -v /tmp/dossier-hote:/dossier-conteneur ubuntu /bin/bash
  • Dans le conteneur, navigons dans ce dossier et créons-y un fichier :
cd /dossier-conteneur/
touch test-depuis-conteneur
  • Sortons ensuite de ce conteneur avec la commande exit
exit
  • Après être sorti·e du conteneur, listons le contenu du dossier sur l’hôte avec la commande suivante ou avec le navigateur de fichiers d’Ubuntu :
ls /tmp/dossier-hote/

Le fichier test-depuis-conteneur a été créé par le conteneur au dossier que l’on avait connecté grâce à -v /tmp/dossier-hote:/dossier-conteneur

  • Tentez de créer un fichier depuis l’hôte dans ce dossier. Que se passe-t-il ? Que faut-il faire ? Pourquoi ?

L’app moby-counter, Redis et les volumes

Pour ne pas interférer avec la deuxième partie du TP :

  • Stoppez tous les conteneurs redis et moby-counter avec docker stop ou avec Portainer.
  • Supprimez les conteneurs arrêtés avec docker container prune
  • Lancez docker volume prune pour faire le ménage de volume éventuellement créés dans les TPs précédent
  • Lancez aussi docker network prune pour nettoyer les réseaux inutilisés

Volumes nommés

Lorsqu’un répertoire hôte spécifique est utilisé dans un volume (la syntaxe -v HOST_DIR:CONTAINER_DIR), elle est souvent appelée bind mounting. C’est quelque peu trompeur, car tous les volumes sont techniquement “bind mounted”. La différence, c’est que le point de montage est explicite plutôt que caché dans un répertoire géré par Docker.

Nous allons recréer un conteneur avec cette fois-ci un volume nommé.

En effet, la bonne façon de créer des volumes consiste à les créer manuellement dans un premier temps (volumes nommés), puis d’y associer un conteneur : docker volume create redis_data.

  • Lancez docker volume inspect redis_data.

  • Créez le conteneur moby-counter à l’intérieur :

docker network create moby-network
docker run -d --network moby-network --name moby-counter -p 8000:80 russmckendrick/moby-counter
  • Puis, à l’aide de la documentation disponible sur le Docker Hub, trouvons le point de montage où connecter un conteneur Redis pour que ses données persistent à la suppression du conteneur.
  • créons le conteneur Redis connecté à notre volume nommé (il faut remplacer __VOLUME__:__POINT_DE_MONTAGE__ par les bonnes informations) :
docker run -d --name redis --network moby-network --volume __VOLUME__:__POINT_DE_MONTAGE__ redis

(facultatif) Deux conteneurs Redis sur un seul volume

  • Créez un réseau moby-network2 et ajoutez un deuxième conteneur redis2 qui va partager les même données que le premier :
    • situé à l’intérieur du nouveau réseau (moby-network2) comme à la partie précédent.
    • utilisant l’option --network-alias redis pour pouvoir être joignable par moby-counter2 (que nous n’avons pas encore créé).
    • partageant le volume de données du premier (cf. cours)
      • monté en read-only (:ro après le paramètre de la question précédente)
Indice :

Le read-only est nécessaire pour que les deux Redis n’écrivent pas de façon contradictoire dans la base de valeurs.

  • Ajoutez une deuxième instance de l’application dans le deuxième réseau connectée à ce nouveau Redis.

  • Visitez la deuxième application : vous devriez voir également le motif de moby apparaître.

Récupérer un volume d’un conteneur supprimé

  • supprimez le conteneur redis : docker stop redis puis docker rm redis

  • recréons le conteneur redis, mais par erreur nous allons oublier de le connecter à un volume à la création :

docker run -d --name redis --network moby-network redis
docker run -d --name moby-counter --network moby-network -p 8000:80 russmckendrick/moby-counter
  • Visitez votre application dans le navigateur. Faites un motif reconnaissable en cliquant.

  • supprimez le nouveau conteneur redis : docker stop redis puis docker rm redis

  • Visitez votre application dans le navigateur. Elle est maintenant déconnectée de son backend.

  • Avons-nous vraiment perdu les données de notre conteneur précédent ? Non ! Le Dockerfile pour l’image officielle Redis ressemble à ça :

FROM alpine:3.5

RUN addgroup -S redis && adduser -S -G redis redis
RUN apk add --no-cache 'su-exec>=0.2'
ENV REDIS_VERSION 3.0.7
ENV REDIS_DOWNLOAD_URL http://download.redis.io/releases/redis-3.0.7.tar.gz
ENV REDIS_DOWNLOAD_SHA e56b4b7e033ae8dbf311f9191cf6fdf3ae974d1c
RUN set -x \
 && apk add --no-cache --virtual .build-deps \
 gcc \
 linux-headers \
 make \
 musl-dev \
 tar \
 && wget -O redis.tar.gz "$REDIS_DOWNLOAD_URL" \
    && echo "$REDIS_DOWNLOAD_SHA \*redis.tar.gz" | sha1sum -c - \
 && mkdir -p /usr/src/redis \
 && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
 && rm redis.tar.gz \
 && make -C /usr/src/redis \
 && make -C /usr/src/redis install \
 && rm -r /usr/src/redis \
 && apk del .build-deps

RUN mkdir /data && chown redis:redis /data
VOLUME /data
WORKDIR /data
COPY docker-entrypoint.sh /usr/local/bin/
RUN ln -s usr/local/bin/docker-entrypoint.sh /entrypoint.sh # backwards compat
ENTRYPOINT ["docker-entrypoint.sh"]
EXPOSE 6379
CMD [ "redis-server" ]

Notez que, vers la fin du fichier, il y a une instruction VOLUME ; cela signifie que lorque notre conteneur a été lancé, un volume “caché” a effectivement été créé par Docker.

Beaucoup de conteneurs Docker sont des applications stateful, c’est-à-dire qui stockent des données. Automatiquement ces conteneurs créent des volument anonymes en arrière plan qu’il faut ensuite supprimer manuellement (avec rm ou prune).

  • Inspectez la liste des volumes (par exemple avec Portainer) pour retrouver l’identifiant du volume caché. Normalement il devrait y avoir un volume portainer_data (si vous utilisez Portainer) et un volume anonyme avec un hash.

  • Créez un nouveau conteneur redis en le rattachant au volume redis “caché” que vous avez retrouvé (en copiant l’id du volume anonyme) : docker container run -d --name redis -v <volume_id>/_data:/data --network moby-network redis:alpine

  • Visitez la page de l’application. Normalement un motif de logos moby d’une précédente session devrait s’afficher (après un délai pouvant aller jusqu’à plusieurs minutes)

  • Affichez le contenu du volume avec la commande : docker exec redis ls -lha /data

Supprimer les volumes et réseaux

  • Pour nettoyer tout ce travail, arrêtez d’abord les différents conteneurs redis et moby-counter.

  • Lancez la fonction prune pour les conteneurs d’abord, puis pour les réseaux, et enfin pour les volumes.

Comme les réseaux et volumes n’étaient plus attachés à des conteneurs en fonctionnement, ils ont été supprimés.

Généralement, il faut faire beaucoup plus attention au prune de volumes (données à perdre) qu’au prune de conteneurs (rien à perdre car immutable et en général dans le registry).

Facultatif : utiliser VOLUME avec microblog

  • Clonons le repo microblog ailleurs :
git clone https://github.com/uptime-formation/microblog/ --branch tp2-dockerfile microblog-volume
  • Ouvrons ça avec VSCode : code microblog-volume

  • Lire le Dockerfile de l’application microblog.

Un volume Docker apparaît comme un dossier à l’intérieur du conteneur. Nous allons faire apparaître le volume Docker comme un dossier à l’emplacement /data sur le conteneur.

  • Pour que l’app Python soit au courant de l’emplacement de la base de données, ajoutez à votre Dockerfile une variable d’environnement DATABASE_URL ainsi (cette variable est lue par le programme Python) :
ENV DATABASE_URL=sqlite:////data/app.db

Cela indique que l’on va demander à Python d’utiliser SQLite pour stocker la base de données comme un unique fichier au format .db (SQLite) dans un dossier accessible par le conteneur. On a en fait indiqué à l’app Python que chemin de la base de données est : /data/app.db

  • Ajouter au Dockerfile une instruction VOLUME pour stocker la base de données SQLite de l’application.
Solution :
  • Créez un volume nommé appelé microblog_db, et lancez un conteneur l’utilisant, créez un compte et écrivez un message.
  • Vérifier que le volume nommé est bien utilisé en branchant un deuxième conteneur microblog utilisant le même volume nommé.

Facultatif : Packagez votre propre app

Vous possédez tous les ingrédients pour packager l’app de votre choix désormais ! Récupérez une image de base, basez-vous sur un Dockerfile existant s’il vous inspire, et lancez-vous !

4 - Créer une application multiconteneur

Docker Compose

  • Nous avons pu constater que lancer plusieurs conteneurs liés avec leur mapping réseau et les volumes liés implique des commandes assez lourdes. Cela devient ingérable si l’on a beaucoup d’applications microservice avec des réseaux et des volumes spécifiques.

  • Pour faciliter tout cela et dans l’optique d'Infrastructure as Code, Docker introduit un outil nommé docker-compose qui permet de décrire de applications multiconteneurs grâce à des fichiers YAML.

  • Pour bien comprendre qu’il ne s’agit que de convertir des options de commande Docker en YAML, un site vous permet de convertir une commande docker run en fichier Docker Compose : https://www.composerize.com/

  • Le “langage” de Docker Compose : la documentation du langage (DSL) des compose-files est essentielle.


A quoi ça ressemble, YAML ?

- marché:
    lieu: Marché de la Défense
    jour: jeudi
    horaire:
      unité: "heure"
      min: 12
      max: 20
    fruits:
      - nom: pomme
        couleur: "verte"
        pesticide: avec

      - nom: poires
        couleur: jaune
        pesticide: sans
    légumes:
      - courgettes
      - salade
      - potiron

Syntaxe

  • Alignement ! (2 espaces !!)

  • ALIGNEMENT !! (comme en python)

  • ALIGNEMENT !!! (le défaut du YAML, pas de correcteur syntaxique automatique, c’est bête mais vous y perdrez forcément quelques heures !

  • des listes (tirets)

  • des paires clé: valeur

  • Un peu comme du JSON, avec cette grosse différence que le JSON se fiche de l’alignement et met des accolades et des points-virgules

  • les extensions Docker et YAML dans VSCode vous aident à repérer des erreurs


Un exemple de fichier Docker Compose

services:
  postgres:
    image: postgres:10
    environment:
      POSTGRES_USER: rails_user
      POSTGRES_PASSWORD: rails_password
      POSTGRES_DB: rails_db
    networks:
      - back_end

  redis:
    image: redis:3.2-alpine
    networks:
      - back_end

  rails:
    build: .
    depends_on:
      - postgres
      - redis
    environment:
      DATABASE_URL: "postgres://rails_user:rails_password@postgres:5432/rails_db"
      REDIS_HOST: "redis:6379"
    networks:
      - front_end
      - back_end
    volumes:
      - .:/app

  nginx:
    image: nginx:latest
    networks:
      - front_end
    ports:
      - 3000:80
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro

networks:
  front_end:
  back_end:

Un deuxième exemple :

services:
  wordpress:
    depends_on:
      - mysqlpourwordpress
    environment:
      - "WORDPRESS_DB_HOST=mysqlpourwordpress:3306"
      - WORDPRESS_DB_PASSWORD=monwordpress
      - WORDPRESS_DB_USER=wordpress
    networks:
    - wordpress
    ports:
      - "80:80"
    image: wordpress
    volumes:
      - wordpress_config:/var/www/html/

  mysqlpourwordpress:
    image: "mysql:5.7"
    environment:
      - MYSQL_ROOT_PASSWORD=motdepasseroot
      - MYSQL_DATABASE=wordpress
      - MYSQL_USER=wordpress
      - MYSQL_PASSWORD=monwordpress
    networks:
    - wordpress
    volumes:
      - wordpress_data:/var/lib/mysql/

networks:
  wordpress:

volumes:
  wordpress_config:
  wordpress_data:


Le workflow de Docker Compose

Les commandes suivantes sont couramment utilisées lorsque vous travaillez avec Compose. La plupart se passent d’explications et ont des équivalents Docker directs, mais il vaut la peine d’en être conscient·e :

  • up démarre tous les conteneurs définis dans le fichier compose et agrège la sortie des logs. Normalement, vous voudrez utiliser l’argument -d pour exécuter Compose en arrière-plan.

  • build reconstruit toutes les images créées à partir de Dockerfiles. La commande up ne construira pas une image à moins qu’elle n’existe pas, donc utilisez cette commande à chaque fois que vous avez besoin de mettre à jour une image (quand vous avez édité un Dockerfile). On peut aussi faire docker-compose up --build

  • ps fournit des informations sur le statut des conteneurs gérés par Compose.

  • run fait tourner un conteneur pour exécuter une commande unique. Cela aura aussi pour effet de faire tourner tout conteneur décrit dans depends_on, à moins que l’argument --no-deps ne soit donné.

  • logs affiche les logs. De façon générale la sortie des logs est colorée et agrégée pour les conteneurs gérés par Compose. logs -f pour suivre les logs en temps réel.

  • stop arrête les conteneurs sans les enlever.

  • rm enlève les contenants à l’arrêt. N’oubliez pas d’utiliser l’argument -v pour supprimer tous les volumes gérés par Docker.

  • down détruit tous les conteneurs définis dans le fichier Compose, ainsi que les réseaux

Le “langage” de Docker Compose


Visualisation des applications microservice complexes

  • Certaines applications microservice peuvent avoir potentiellement des dizaines de petits conteneurs spécialisés. Le service devient alors difficile à lire dans le compose file.

  • Il est possible de visualiser l’architecture d’un fichier Docker Compose en utilisant docker-compose-viz-mermaid

  • Cet outil peut être utilisé dans un cadre d’intégration continue pour produire automatiquement la documentation pour une image en fonction du code.

TP 4 - Créer une application multiconteneur

Articuler trois images avec Docker Compose

Si Docker Compose est pas installé

identidock : une application Flask qui se connecte à redis

  • Démarrez un nouveau projet dans VSCode (créez un dossier appelé identidock et chargez-le avec la fonction Add folder to workspace)
  • Dans un sous-dossier app, ajoutez une petite application python en créant ce fichier identidock.py :
from flask import Flask, Response, request, abort
import requests
import hashlib
import redis
import os
import logging

LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
logging.basicConfig(level=LOGLEVEL)

app = Flask(__name__)
cache = redis.StrictRedis(host='redis', port=6379, db=0)
salt = "UNIQUE_SALT"
default_name = 'toi'

@app.route('/', methods=['GET', 'POST'])
def mainpage():

    name = default_name
    if request.method == 'POST':
        name = request.form['name']

    salted_name = salt + name
    name_hash = hashlib.sha256(salted_name.encode()).hexdigest()
    header = '<html><head><title>Identidock</title></head><body>'
    body = '''<form method="POST">
                Salut <input type="text" name="name" value="{0}"> !
                <input type="submit" value="submit">
                </form>
                <p>Tu ressembles a ca :
                <img src="/monster/{1}"/>
            '''.format(name, name_hash)
    footer = '</body></html>'
    return header + body + footer


@app.route('/monster/<name>')
def get_identicon(name):
    found_in_cache = False

    try:
        image = cache.get(name)
        redis_unreachable = False
        if image is not None:
            found_in_cache = True
            logging.info("Image trouvee dans le cache")
    except:
        redis_unreachable = True
        logging.warning("Cache redis injoignable")

    if not found_in_cache:
        logging.info("Image non trouvee dans le cache")
        try:
            r = requests.get('http://dnmonster:8080/monster/' + name + '?size=80')
            image = r.content
            logging.info("Image generee grace au service dnmonster")

            if not redis_unreachable:
                cache.set(name, image)
                logging.info("Image enregistree dans le cache redis")
        except:
            logging.critical("Le service dnmonster est injoignable !")
            abort(503)

    return Response(image, mimetype='image/png')

if __name__ == '__main__':
  app.run(debug=True, host='0.0.0.0', port=5000)
  • uWSGI est un serveur python de production très adapté pour servir notre serveur intégré Flask, nous allons l’utiliser.

  • Dockerisons maintenant cette nouvelle application avec le Dockerfile suivant :

FROM python:3.7

RUN groupadd -r uwsgi && useradd -r -g uwsgi uwsgi
RUN pip3 install Flask uWSGI requests redis
WORKDIR /app
COPY app/identidock.py /app
ENV FLASK_APP identidock.py

EXPOSE 5000 9191
USER uwsgi
CMD ["uwsgi", "--http", "0.0.0.0:5000", "--wsgi-file", "/app/identidock.py", \
"--callable", "app", "--stats", "0.0.0.0:9191"]
  • Observons le code du Dockerfile ensemble s’il n’est pas clair pour vous. Juste avant de lancer l’application, nous avons changé d’utilisateur avec l’instruction USER, pourquoi ?.

Le fichier Docker Compose

  • A la racine de notre projet identidock (à côté du Dockerfile), créez un fichier de déclaration de notre application appelé docker-compose.yml avec à l’intérieur :
services:
  identidock:
    build: .
    ports:
      - "5000:5000"
  • Plusieurs remarques :

    • la première ligne après services déclare le conteneur de notre application
    • les lignes suivantes permettent de décrire comment lancer notre conteneur
    • build: . indique que l’image d’origine de notre conteneur est le résultat de la construction d’une image à partir du répertoire courant (équivaut à docker build -t identidock .)
    • la ligne suivante décrit le mapping de ports entre l’extérieur du conteneur et l’intérieur.
  • Lancez le service (pour le moment mono-conteneur) avec docker compose up (cette commande sous-entend docker compose build)

  • Visitez la page web de l’app.

  • Ajoutons maintenant un deuxième conteneur. Nous allons tirer parti d’une image déjà créée qui permet de récupérer une “identicon”. Ajoutez à la suite du fichier Compose (attention aux indentations !) un service dnmonster utilisant l’image amouat/dnmonster:1.0.

Solution :
  • Enfin, nous déclarons aussi un réseau appelé identinet pour y mettre les deux conteneurs de notre application.
Solution :
  • Il faut aussi mettre nos deux services identidock et dnmonster sur le même réseau en ajoutant deux fois ce bout de code où c’est nécessaire (attention aux indentations !) :
  networks:
    - identinet
  • Ajoutons également un conteneur redis (attention aux indentations !). Cette base de données sert à mettre en cache les images et à ne pas les recalculer à chaque fois.
Solution :
`docker-compose.yml` final :
  • Lancez l’application et vérifiez que le cache fonctionne en cherchant les messages dans les logs de l’application.

  • N’hésitez pas à passer du temps à explorer les options et commandes de docker-compose, ainsi que la documentation officielle du langage des Compose files.

Le Hot Code Reloading (rechargement du code à chaud)

Modifions le docker-compose.yml pour y inclure des instructions pour lancer le serveur python en mode debug.

Notre image est codée pour lancer le serveur de production appelé uWSGI (CMD ["uwsgi", "--http", "0.0.0.0:5000", "--wsgi-file", "/app/identidock.py", \ "--callable", "app", "--stats", "0.0.0.0:9191"]). Nous voulons plutôt lancer le serveur de debug qui se lance avec :

  • la variable d’environnement FLASK_ENV=development
  • le processus lancé avec la commande flask run -h 0.0.0.0

En réfléchissant à comment utiliser les volumes, le but est de trouver comment la modification du code source devrait immédiatement être répercutée dans les logs d'identidock : recharger la page devrait nous montrer la nouvelle version du code de l’application.

Solution :

(facultatif) Monter un script d’entrypoint

En vous inspirant de ce fichier, créez un script d’entrypoint et déclarez un volume pour l’utiliser.

#!/bin/sh

# cette partie sert à effectuer des opérations sur la base de données si nécessaires
while true; do
    if flask db upgrade; then
        break
    fi
    echo Deploy command failed, retrying in 5 secs...
    sleep 5
done

# cette partie permet de faire varier l'environnement du container
set -e
if [ "$CONTEXT" = 'DEV' ]; then
    echo "Running Development Server"
    FLASK_ENV=development exec flask run -h 0.0.0.0
else
    echo "Running Production Server"
    exec gunicorn -b :5000 --access-logfile - --error-logfile - microblog:app
fi

(facultatif) Le Docker Compose de microblog

Créons un fichier Docker Compose pour faire fonctionner l’application Microblog du TP précédent avec Postgres.

  • Quelles étapes faut-il ?
  • Trouver comment configurer une base de données Postgres pour une app Flask (c’est une option de SQLAlchemy)

D’autres services

Exercices de google-fu

ex: un pad HedgeDoc

On se propose ici d’essayer de déployer plusieurs services pré-configurés comme Wordpress, Nextcloud, Sentry ou votre logiciel préféré.

  • Récupérez (et adaptez si besoin) à partir d’Internet un fichier docker-compose.yml permettant de lancer un pad HedgeDoc ou autre avec sa base de données. Je vous conseille de toujours chercher dans la documentation officielle ou le repository officiel (souvent sur Github) en premier.

  • Vérifiez que le service est bien accessible sur le port donné.

  • Si besoin, lisez les logs en quête bug et adaptez les variables d’environnement.

Partie 2 - Thèmes avancés

TP 5 - Logging et monitoring

Les drivers de logs

Dans Docker, le driver de logs par défaut est json-file. Son inconvénient majeur est que les logs avec ce driver sont supprimés dès que le conteneur est supprimé.

Utiliser le driver journald

  • A l’aide de la documentation, changeons le driver dans /etc/docker/daemon.json pour utiliser le driver journald.
  • Relancez le service docker.service
  • Consultez les logs d’un conteneur grâce à journalctl -f et le bon label.

Ce driver est utile car les logs sont désormais archivés dès leur création, tout en permettant d’utiliser les features de filtrage et de rotation de journald.

  • Remettez le driver par défaut (json-file ou supprimez le fichier /etc/docker/daemon.json), et restartez le service docker.service pour ne pas interférer avec la seconde moitié de l’exercice : la config Elastic de l’exercice suivant fonctionne avec le driver json-file.

Une stack Elastic

Centraliser les logs

L’utilité d’Elasticsearch est que, grâce à une configuration très simple de son module Filebeat, nous allons pouvoir centraliser les logs de tous nos conteneurs Docker. Pour ce faire, il suffit d’abord de télécharger une configuration de Filebeat prévue à cet effet :

curl -L -O https://raw.githubusercontent.com/elastic/beats/7.10/deploy/docker/filebeat.docker.yml

Renommons cette configuration et rectifions qui possède ce fichier pour satisfaire une contrainte de sécurité de Filebeat :

mv filebeat.docker.yml filebeat.yml
sudo chown root filebeat.yml
sudo chmod go-w filebeat.yml

Enfin, créons un fichier docker-compose.yml pour lancer une stack Elasticsearch :

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.5.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    networks:
      - logging-network

  filebeat:
    image: docker.elastic.co/beats/filebeat:7.5.0
    user: root
    depends_on:
      - elasticsearch
    volumes:
      - ./filebeat.yml:/usr/share/filebeat/filebeat.yml:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - logging-network
    environment:
      - -strict.perms=false

  kibana:
    image: docker.elastic.co/kibana/kibana:7.5.0
    depends_on:
      - elasticsearch
    ports:
      - 5601:5601
    networks:
      - logging-network

networks:
  logging-network:
    driver: bridge

Il suffit ensuite de :

  • se rendre sur Kibana (port 5601)
  • de configurer l’index en tapant * dans le champ indiqué, de valider
  • et de sélectionner le champ @timestamp, puis de valider.

L’index nécessaire à Kibana est créé, vous pouvez vous rendre dans la partie Discover à gauche (l’icône boussole 🧭) pour lire vos logs.

Il est temps de faire un petit docker stats pour découvrir l’utilisation du CPU et de la RAM de vos conteneurs !

Parenthèse : Avec WSL

Avec WSL, l’emplacement des logs est assez difficile à trouver ! Vous pouvez vous aider de cette page pour ce TP : https://gist.github.com/Bert-R/e5bb77b9ce9c94fdb1a90e4e615ee518

Facultatif : Ajouter un nœud Elasticsearch

Puis, à l’aide de la documentation Elasticsearch et/ou en adaptant de bouts de code Docker Compose trouvés sur internet, ajoutez et configurez un nœud Elastic. Toujours à l’aide de la documentation Elasticsearch, vérifiez que ce nouveau nœud communique bien avec le premier.

Facultatif : ajouter une stack ELK à microblog

Dans la dernière version de l’app microblog, Elasticsearch est utilisé pour fournir une fonctionnalité de recherche puissante dans les posts de l’app. Avec l’aide du tutoriel de Miguel Grinberg, écrivez le docker-compose.yml qui permet de lancer une stack entière pour microblog. Elle devra contenir un conteneur microblog, un conteneur mysql, un conteneur elasticsearch et un conteneur kibana.

Facultatif : du monitoring avec cAdvisor et Prometheus

Suivre ce tutoriel pour du monitoring des conteneurs Docker : https://prometheus.io/docs/guides/cadvisor/

On pourra se servir de cette stack Compose : https://github.com/vegasbrianc/prometheus/

Vous pouvez aussi aspirer le port 9191 du container identidock qui affiche un JSON de stats du serveur Gunicorn.

Ressources supplémentaires

Une alternative est Netdata, joli et configuré pour monitorer des conteneurs out-of-the-box : https://learn.netdata.cloud/docs/netdata-agent/installation/docker

On peut aussi regarder du côté de Signoz (logging, monitoring et alerting) : https://github.com/SigNoz/signoz

Ou bien Loki : https://grafana.com/docs/loki/latest/setup/install/docker/

Ressources utiles :

6 - Considérations de sécurité dans Docker

Sécurité / durcissement

  • un conteneur privilégié est root sur la machine !

    • et l’usage des capabilities Linux dès que possible pour éviter d’utiliser --privileged
    • on peut utiliser bane, un générateur de profil AppArmor pour Docker
    • dans l’écrasante majorité des cas, on peut se concentrer sur les capabilities (pour des conteneurs non privilégiés) pour avoir un cluster Docker déjà très sécurisé.
    • SELinux peut s’activer sur les systèmes RedHat : plusieurs règles liées à la conteneurisation sont ajoutées au système hôte pour rendre plus difficile une exploitation via un conteneur. Cela s’active dans les options du daemon Docker : https://www.arhea.net/posts/2020-04-28-selinux-for-containers/
    • les profils seccomp ont une logique similaire : ils désactivent certains appels kernel (syscall) pour rendre plus difficile une exploitation (voir https://docs.docker.com/engine/security/seccomp/). En général on utilise un profil par défaut.
  • des cgroups corrects par défaut dans la config Docker : ulimit -a et docker stats

  • par défaut les user namespaces ne sont pas utilisés !

  • le benchmark Docker CIS : https://github.com/docker/docker-bench-security/

  • La sécurité de Docker c’est aussi celle de la chaîne de dépendance, des images, des packages installés dans celles-ci : on fait confiance à trop de petites briques dont on ne vérifie pas la provenance ou la mise à jour

    • Docker Scout, Clair ou Trivy : l’analyse statique d’images Docker grâce aux bases de données de CVEs

    • Watchtower : un conteneur ayant pour mission de périodiquement recréer les conteneurs pour qu’ils utilisent la dernière image Docker

  • docker-socket-proxy : protéger la socket Docker quand on a besoin de la partager à des conteneurs comme Traefik ou Portainer

Les registries privés

Un registry avancé, par exemple avec Harbor, permet d’activer le scanning d’images, de gérer les droits d’usage d’images, et de potentiellement restreindre les images utilisables dans des contextes d’organisation sécurisés.

TP 6 - Renforcement de la sécurité avec Docker

Découverte de Podman

Avec l’aide du mode d’emploi rootless de Podman, découvrons ensemble les choix d’architecture de Podman et son mode rootless par défaut : https://podman.io/docs/installation

Note : il est aussi possible d’utiliser docker-compose avec Podman grâce à l’activation de son API.

Ressources pour le debugging si nécessaire :

Les options de dockerd : le fichier daemon.json

Revenons à Docker. On peut spécifier des options plus sécurisées, soit en modifiant le service docker.service, soit en modifiant le fichier /etc/docker/daemon.json (plus recommandé).

  • par exemple, on peut choisir certaines valeurs plus restrictives pour les cgroups, pour éviter qu’un conteneur trop gourmand bloque le host (se référer à la documentation).

Configurer les user namespaces

Par défault, et à cause de leur côté contre-intuitif, ils ne sont pas utilisés !

Voici la documentation détaillée de leur fonctionnement : https://docs.docker.com/engine/security/userns-remap/#enable-userns-remap-on-the-daemon

  • Activons-les grâce à une option spéciale :

/etc/docker/driver.json :

{
    "userns-remap": "default"
}
  • Relancez le service docker.service

  • Observez ces fichiers :

    • /etc/subuid
    • /etc/passwd
  • Montez le dossier / (racine) dans un conteneur : que s’est-il passé ?

docker run -it -v /:/dossier-racine-hote ubuntu /bin/bash
  • Faites un id depuis un conteneur

  • Avec docker inspect et ps -aux, trouvez le UID effectif d’un conteneur après l’activation de cette option.

Lancer un audit sur l’installation Docker

Facultatif : inter-container communication on default network

Désactivez l’options icc dans le fichier daemon.json et relancez l’audit. Tentez de pinger un conteneur depuis un autre (voir TP3 sur le réseau pour un exemple).

Le contenu des images Docker

Utiliser un scanner d’images Docker

La sécurité de Docker c’est aussi celle de la chaîne de dépendance, des images, des packages installés dans celles-ci : on fait confiance à trop de petites briques dont on ne vérifie pas la provenance ou la mise à jour

En production, on peut utiliser Watchtower : un conteneur ayant pour mission de périodiquement récupérer des images et recréer les conteneurs pour qu’ils utilisent la dernière image Docker

Un registry avancé avec Harbor

Un registry avancé, par exemple avec Harbor, permet d’activer le scanning d’images, de gérer les droits d’usage d’images, et de potentiellement restreindre les images utilisables dans des contextes d’organisation sécurisés.

Voir la démo : https://goharbor.io/docs/2.10.0/install-config/demo-server/

Le renforcement de sécurité : les profils AppArmor

AppArmor est plus haut niveau que SELinux (qui s’active dans daemon.json mais que sur les systèmes RedHat).

  • Dans l’écrasante majorité des cas, on peut se concentrer sur les capabilities (pour des conteneurs non privilégiés) pour avoir un cluster Docker déjà très sécurisé.

7 - Orchestration et clustering

Orchestration

  • Un des intérêts principaux de Docker et des conteneurs en général est de :

    • favoriser la modularité et les architectures microservice.
    • permettre la scalabilité (mise à l’échelle) des applications en multipliant les conteneurs.
  • A partir d’une certaine échelle, il n’est plus question de gérer les serveurs et leurs conteneurs à la main.

Les nœuds d’un cluster sont les machines (serveurs physiques, machines virtuelles, etc.) qui font tourner vos applications (composées de conteneurs).

L’orchestration consiste à automatiser la création et la répartition des conteneurs à travers un cluster de serveurs. Cela peut permettre de :

  • déployer de nouvelles versions d’une application progressivement.
  • faire grandir la quantité d’instances de chaque application facilement.
  • voire dans le cas de l’auto-scaling de faire grossir l’application automatiquement en fonction de la demande.

Docker Swarm

  • Swarm est l'outil de clustering et d’orchestration natif de Docker (développé par Docker Inc.).

  • Il s’intègre très bien avec les autres commandes docker (on a même pas l’impression de faire du clustering).

  • Il permet de gérer de très grosses productions Docker.

  • Swarm utilise l’API standard du Docker Engine (sur le port 2376) et sa propre API de management Swarm (sur le port 2377).

  • Il a perdu un peu en popularité face à Kubernetes mais c’est très relatif (voir comparaison plus loin).


Architecture de Docker Swarm


  • Un ensemble de nœuds de contrôle pour gérer les conteneurs
  • Un ensemble de nœuds worker pour faire tourner les conteneurs
  • Les nœuds managers sont en fait aussi des workers et font tourner des conteneurs, c’est leur rôles qui varient.

Consensus entre managers Swarm

  • L’algorithme Raft : http://thesecretlivesofdata.com/raft/

  • Pas d'intelligent balancing dans Swarm

    • l’algorithme de choix est “spread”, c’est-à-dire qu’il répartit au maximum en remplissant tous les nœuds qui répondent aux contraintes données.

Docker Services et Stacks

  • les services : la distribution d’un seul conteneur en plusieurs exemplaires

  • les stacks : la distribution (en plusieurs exemplaires) d’un ensemble de conteneurs (app multiconteneurs) décrits dans un fichier Docker Compose


services:
  web:
    image: username/repo
    deploy:
      replicas: 5
      resources:
        limits:
          cpus: "0.1"
          memory: 50M
      restart_policy:
        condition: on-failure
    ports:
      - "4000:80"
    networks:
      - webnet
networks:
  webnet:
  • Référence pour les options Swarm de Docker Compose : https://docs.docker.com/compose/compose-file/#deploy
  • Le mot-clé deploy est lié à l’usage de Swarm
    • options intéressantes :
      • update_config : pour pouvoir rollback si l’update fail
      • placement : pouvoir choisir le nœud sur lequel sera déployé le service
      • replicas : nombre d’exemplaires du conteneur
      • resources : contraintes d’utilisation de CPU ou de RAM sur le nœud

Sous-commandes Swarm

  • swarm init : Activer Swarm et devenir manager d’un cluster d’un seul nœud

  • swarm join : Rejoindre un cluster Swarm en tant que nœud manager ou worker

  • service create : Créer un service (= un conteneur en plusieurs exemplaires)

  • service inspect : Infos sur un service

  • service ls : Liste des services

  • service rm : Supprimer un service

  • service scale : Modifier le nombre de conteneurs qui fournissent un service

  • service ps : Liste et état des conteneurs qui fournissent un service

  • service update : Modifier la définition d’un service

  • docker stack deploy : Déploie une stack (= fichier Docker compose) ou update une stack existante

  • docker stack ls : Liste les stacks

  • docker stack ps : Liste l’état du déploiement d’une stack

  • docker stack rm : Supprimer une ou des stacks

  • docker stack services : Liste les services qui composent une stack

  • docker node inspect : Informations détaillées sur un nœud

  • docker node ls : Liste les nœuds

  • docker node ps : Liste les tâches en cours sur un nœud

  • docker node promote : Transforme un nœud worker en manager

  • docker node demote : Transforme un nœud manager en worker


Répartition de charge (load balancing)

  • Un load balancer : une sorte d'“aiguillage” de trafic réseau, typiquement HTTP(S) ou TCP.

  • Un aiguillage intelligent qui se renseigne sur plusieurs critères avant de choisir la direction.

  • Cas d’usage :

    • Éviter la surcharge : les requêtes sont réparties sur différents backends pour éviter de les saturer.
  • Haute disponibilité : on veut que notre service soit toujours disponible, même en cas de panne (partielle) ou de maintenance.

  • Donc on va dupliquer chaque partie de notre service et mettre les différentes instances derrière un load balancer.

  • Le load balancer va vérifier pour chaque backend s’il est disponible (healthcheck) avant de rediriger le trafic.

  • Répartition géographique : en fonction de la provenance des requêtes on va rediriger vers un datacenter adapté (+ ou - proche)


Le loadbalancing de Swarm est automatique

  • Loadbalancer intégré : Ingress

  • Permet de router automatiquement le trafic d’un service vers les nœuds qui l’hébergent et sont disponibles.

  • Pour héberger une production il suffit de rajouter un loadbalancer externe qui pointe vers un certain nombre de nœuds du cluster et le trafic sera routé automatiquement à partir de l’un des nœuds.


Solutions de loadbalancing externe

  • HAProxy : Le plus répandu en loadbalancing
  • Træfik : Simple à configurer et fait pour l’écosystème Docker
  • NGINX : Serveur web générique mais a depuis quelques années des fonctions puissantes de loadbalancing et de TCP forwarding.

Gérer les données sensibles dans Swarm avec les secrets Docker

  • echo "This is a secret" | docker secret create my_secret_data

  • docker service create --name monservice --secret my_secret_data redis:alpine => monte le contenu secret dans /var/run/my_secret_data


Docker Machine

  • C’est l’outil de gestion d’hôtes Docker
  • Il est capable de créer des serveurs Docker “à la volée”
  • Concrètement, docker-machine permet de créer automatiquement des machines avec le Docker Engine et ssh configuré et de gérer les certificats TLS pour se connecter à l’API Docker des différents serveurs.

  • Il permet également de changer le contexte de la ligne de commande Docker pour basculer sur l’un ou l’autre serveur avec les variables d’environnement adéquates.

  • Il permet également de se connecter à une machine en ssh en une simple commande.

Exemple :

 docker-machine create  --driver digitalocean \
      --digitalocean-ssh-key-fingerprint 41:d9:ad:ba:e0:32:73:58:4f:09:28:15:f2:1d:ae:5c \
      --digitalocean-access-token "a94008870c9745febbb2bb84b01d16b6bf837b4e0ce9b516dbcaf4e7d5ff2d6" \
      hote-digitalocean

Pour basculer eval $(docker env hote-digitalocean);

  • docker run -d nginx:latest créé ensuite un conteneur sur le droplet digitalocean précédemment créé.

  • docker ps -a affiche le conteneur en train de tourner à distance.

  • wget $(docker-machine ip hote-digitalocean) va récupérer la page nginx.


Présentation de Kubernetes

  • Les pods Kubernetes servent à grouper des conteneurs en unités d’application (microservices ou non) fortement couplées (un peu comme les stacks Swarm)

  • Les services sont des abstractions réseau pour exposer des groupes de pods à l’extérieur

  • Les deployments sont une abstraction pour scaler ou mettre à jours des groupes de pods (un peu comme les tasks dans Swarm).


Présentation de Kubernetes

  • Une autre solution très à la mode depuis 4 ans. Un buzz word du DevOps en France :)

  • Une solution robuste, structurante et open source d’orchestration Docker.

  • Au cœur du consortium Cloud Native Computing Foundation très influent dans le monde de l’informatique.

  • Hébergeable de façon identique dans le cloud, on-premise ou en mixte.

  • Kubernetes a un flat network (un overlay de plus bas niveau que Swarm) : https://neuvector.com/network-security/kubernetes-networking/


Comparaison Swarm et Kubernetes

  • Swarm plus intégré avec la CLI et le workflow Docker.
  • Swarm est plus fluide, moins structurant mais moins automatique que Kubernetes.
  • Kubernetes a une meilleure fault tolerance que Swarm
    • attention au contre-sens : un service Swarm est un seul conteneur répliqué, un service Kubernetes est un objet réseau vers un groupe de pods.

Comparaison Swarm et Kubernetes

  • Kubernetes a plus d’outils intégrés. Il s’agit plus d’un écosystème qui couvre un large panel de cas d’usage.
  • Swarm est beaucoup plus simple à mettre en œuvre qu’une stack Kubernetes.
  • Swarm serait donc mieux pour les clusters moyen et Kubernetes pour les très gros

TP 7 - Orchestration et clustering

Introduction à Swarm

  • Se grouper par 2 ou 3 pour créer un cluster à partir de vos VM respectives (il faut utiliser une commande Swarm pour récupérer les instructions nécessaires : docker swarm init devrait vous orienter).

  • Si grouper plusieurs des VM n’est pas possible, vous pouvez faire un cluster à un seul noeud, ou bien créer un cluster multi-nodes très simplement avec l’interface du site Play With Docker, il faut s’y connecter avec vos identifiants Docker Hub. Vous pouvez vous connecter à ces VM en SSH.

  • Vous pouvez faire docker swarm --help pour obtenir des infos manquantes, ou faire docker swarm leave --force pour réinitialiser votre configuration Docker Swarm si besoin.

  • N’hésitez pas à regarder dans les logs avec systemctl status docker comment se passe l’élection du nœud leader, à partir du moment où vous avez plus d’un manager.

Créer un service

Afin de visualiser votre installation Swarm, utilisons : https://github.com/dockersamples/docker-swarm-visualizer

docker run -d -p 8080:8080 -v /var/run/docker.sock:/var/run/docker.sock dockersamples/visualizer

En ligne de commande

En ligne de commande : docker service create --name whoami --replicas 5 -p 9999:80 traefik/whoami

Avec la clé deploy:

A l’aide de la propriété deploy: de docker compose, créer un service en 5 exemplaires (replicas) à partir de l’image traefik/whoami accessible sur le port 9999 et connecté au port 80 des 5 replicas.

Solution :

Accédez à votre service depuis un node et actualisez plusieurs fois la page (Ctrl+Maj+R sinon le cache du navigateur vous embêtera). Les informations affichées changent. Pourquoi ?

  • Lancez une commande service scale pour changer le nombre de replicas de votre service et observez le changement avec docker service ps hello

La stack example-voting-app

  • Cloner l’application example-voting-app ici : https://github.com/dockersamples/example-voting-app

  • Lire le schéma d’architecture de l’app example-voting-app sur Github.

  • Lire attentivement le fichier docker-stack.yml. Ce sont des fichiers Docker Compose classiques avec différentes options liées à un déploiement via Swarm. Quelles options semblent spécifiques à Docker Swarm ? Ces options permettent de configurer des fonctionnalités d'orchestration.

  • Avec docker swarm init, transformer son installation Docker en une installation Docker compatible avec Swarm. Lisez attentivement le message qui vous est renvoyé.

  • Déployer la stack du fichier docker-stack.yml : docker stack deploy --compose-file docker-stack.yml vote

  • docker stack ls indique 6 services pour la stack vote. Observer également l’output de docker stack ps vote et de docker stack services vote. Qu’est-ce qu’un service dans la terminologie de Swarm ?

  • Accéder aux différents front-ends de la stack grâce aux informations contenues dans les commandes précédentes. Sur le front-end lié au vote, actualiser plusieurs fois la page. Que signifie la ligne Processed by container ID […] ? Pourquoi varie-t-elle ?

  • Scaler la stack en ajoutant des replicas du front-end lié au vote avec l’aide de docker service --help. Accédez à ce front-end et vérifier que cela a bien fonctionné en actualisant plusieurs fois.

  • puis spécifier quelques options d’orchestration exclusives à Docker Swarm : que fait mode: global ? N’oubliez pas de redéployer votre Compose file.

  • Avec Portainer ou avec docker-swarm-visualizer, explorer le cluster ainsi créé.

Opérer sur le cluster

  • Trouver la commande pour déchoir et promouvoir l’un de vos nœuds de manager à worker et vice-versa.

  • Puis sortir un nœud du cluster (drain) : docker node update --availability drain <node-name>

Facultatif : déployer une nouvelle image pour un service de example-voting-app

Tenter :

  • de rebuild les différentes images à partir de leur Dockerfile,
  • puis d’éditer votre fichier Docker Compose (docker-stack.yml) pour qu’il se base sur l’image que vous venez de reconstruire.
  • et de déployer ces images, potentiellement en faisant varier les options de update_config:. Un message de warning devrait apparaître, pourquoi ?

Introduction à Kubernetes

Le fichier kube-deployment.yml de l’app example-voting-app décrit la même app pour un déploiement dans Kubernetes plutôt que dans Docker Compose ou Docker Swarm. Tentez de retrouver quelques équivalences entre Docker Compose / Swarm et Kubernetes en lisant attentivement ce fichier qui décrit un déploiement Kubernetes.

Gérer les données sensibles dans Swarm avec les secrets Docker

  • créer un secret avec : echo "This is a secret" | docker secret create my_secret_data

  • permettre l’accès au secret via : docker service create --name monservice --secret my_secret_data redis:alpine

  • lire le contenu secret dans : /var/run/my_secret_data

Facultatif : stratégies de déploiement et Swarm

A partir d’une commande Curl, observez les changements de version d’un conteneur.

  • Vous pouvez vous servir de cette image qui lit la variable d’environnement VERSION : docker run -e VERSION=v2.0.0 -p 8080:8080 containersol/k8s-deployment-strategies

  • Préparez 2 fichiers : docker-compose.init.yml et docker-compose.upgrade.yml, représentant vos deux scénarios. Vous pouvez vous inspirer de cette page et de son dépôt :

  • Nous allons maintenant mettre à jour, lancez d’abord dans un terminal la commande : while true; do curl localhost:8080; echo; sleep 1; done

  • Appliquez votre docker-compose.upgrade.yml et observez

Facultatif : Utiliser Traefik avec Swarm

Vous pouvez désormais faire l’exercice 2 du TP 7 pour configurer un serveur web qui permet d’accéder à vos services Swarm via des domaines spécifiques.

Facultatif : cluster Postgres haute dispo et Swarm –>

https://www.crunchydata.com/blog/an-easy-recipe-for-creating-a-postgresql-cluster-with-docker-swarm

TP 8 - Intégration continue avec Gitlab

Créer une pipeline de build d’image Docker avec les outils CI/CD Gitlab

  1. Si vous n’en avez pas déjà un, créez un compte sur Gitlab.com : https://gitlab.com/users/sign_in#register-pane
  2. Créez un nouveau projet et avec Git, le Web IDE Gitlab, ou bien en forkant une app existante depuis l’interface Gitlab, poussez-y l’app de votre choix (par exemple microblog, dnmonster ou l’app healthcheck vue au TP2).
  3. Ajoutez un Dockerfile à votre repository ou vérifiez qu’il en existe bien un.
  4. Créez un fichier .gitlab-ci.yml depuis l’interface web de Gitlab et choisissez “Docker” comme template. Observons-le ensemble attentivement.
  5. Faites un commit de ce fichier.
  6. Vérifiez votre CI : il faut vérifier sur le portail de Gitlab comment s’est exécutée la pipeline.
  7. Vérifiez dans la section Container Registry que votre image a bien été push.

Ressources

Avec BitBucket

BitBucket propose aussi son outil de pipeline, à la différence qu’il n’a pas de registry intégré, le template par défaut propose donc de pousser son image sur le registry Docker Hub.

  • Il suffit de créer un repo BitBucket puis d’y ajouter le template de CI Docker proposé (le template est caché derrière un bouton See more).
  • Ensuite, il faut ajouter des Repository variables avec ses identifiants Docker Hub. Dans le template, ce sont les variables DOCKERHUB_USERNAME, DOCKERHUB_PASSWORD et DOCKERHUB_NAMESPACE (identique à l’username ici).

Ressources

Conclusion

Déployer notre container ou notre projet Docker Compose

Nous avons fait la partie CI (intégration continue). Une étape supplémentaire est nécessaire pour ajouter le déploiement continu de l’app (CD) : si aucune étape précédente n’a échoué, la nouvelle version de l’app devra être déployée sur votre serveur, via une connexion SSH et rsync par exemple. Il faudra ajouter des variables secrètes au projet (clé SSH privée par exemple), cela se fait dans les options de Gitlab ou de BitBucket.

TP 9 - Docker et les reverse proxies

Exercice 1a - Utiliser Traefik pour le routage

Traefik est un reverse proxy très bien intégré à Docker. Il permet de configurer un routage entre un point d’entrée (ports 80 et 443 de l’hôte) et des containers Docker, grâce aux informations du daemon Docker et aux labels sur chaque containers. Nous allons nous baser sur le guide d’introduction Traefik - Getting started.

  • Avec l’aide de la documentation Traefik, ajoutez une section pour le reverse proxy Traefik pour dans un fichier Docker Compose de votre choix.
Exemple de Docker Compose :
Solution :
  • Explorez le dashboard Traefik accessible sur le port indiqué dans le fichier Docker Compose.

Pour que Traefik fonctionne, 2 étapes :

  • faire en sorte que Traefik reçoive la requête quand on s’adresse à l’URL voulue (DNS + routage)

  • faire en sorte que Traefik sache vers quel conteneur rediriger le trafic reçu (et qu’il puisse le faire)

  • Ajouter des labels à l’app web que vous souhaitez desservir grâce à Traefik à partir de l’exemple de la doc Traefik, grâce aux labels ajoutés dans le docker-compose.yml (attention à l’indentation).

    Solution :

Exercice 1b - un certificat Let’s Encrypt (ou autosigné)

Utilisons le nom de domaine public de votre VM, normalement communiqué par le formateur.

Solution :

Note pour utiliser un certificat autosigné :

Pour utiliser un certificat autosigné, il n’y a pas besoin de configurer de “cert resolver”, il suffit de bien exposer le port 443 de Traefik et d’adapter la ligne suivante pour chaque service exposé : - "traefik.http.routers.whoami.tls=true"

Exercice 2 - Router vers notre stack identidock

Ajoutons des labels dans notre stack identidock pour l’exposer via Traefik sur l’adresse monster.localhost.

Indice 1 :
Indice 2 :

Attention : il y a un problème assez difficile à comprendre et à résoudre avec Traefik, il n’est pas explicite ! Cette page vous aidera à le résoudre (à rajouter dans le paramètre command: du conteneur Traefik) : https://community.traefik.io/t/docker-provider-how-does-traefik-choose-which-service-ip-address-to-proxy-to-when-container-is-on-multiple-networks/16852/2

Exercice 3 - Swarm avec Traefik

Solution :

Conclusion


Conclusions sur l’écosystème Docker

Configurer de la CI/CD

  • La nature facile à déployer des conteneurs et l’intégration du principe d’Infrastructure-as-Code les rend indispensable dans de la CI/CD (intégration continue et déploiement continu).
  • Les principaux outils de CI sont Gitlab, Jenkins, Github Actions, Travis CI…
    • Gitlab propose par défaut des runners préconfigurés qui utilisent des conteneurs Docker et tournent en général dans un cluster Kubernetes.
    • Gitlab propose aussi un registry d’images Docker, privé ou public, par projet.
  • Les tests à l’intérieur des conteneurs peuvent aussi être faits de façon plus poussée, avec par exemple Ansible comme source de healthcheck ou comme suite pour les tests.
  • Dans une autre catégorie, Gitpod base son workflow sur des images Docker permettant de configurer un environnement de développement

Gérer les logs et monitorer des conteneurs

Logging

Avec Elasticsearch, Filebeat et Kibana… grâce aux labels sur les conteneurs Docker

Ou en utilisant des drivers de logs adéquats : https://docs.docker.com/config/containers/logging/configure/#supported-logging-drivers

Monitoring

Gérer le reverse proxy

Avec Traefik, aussi grâce aux labels sur les conteneurs Docker

Ou avec Nginx, avec deux projets :


Limites de Docker

Stateful

Configurer le réseau de façon plus complexe avec des plugins réseau

  • Réseaux “overlay”: IP in IP, VXLAN…
  • …mais on a rapidement besoin de plugins exclusifs à Kubernetes : Calico, Flannel, Canal (Calico + Flannel), Cilium (qui utilise eBPF)

Volumes distribués

  • problème des volumes partagés / répliqués
    • domaine à part entière
    • Solution 1 : solutions applicatives robustes
    • Solution 2 : volume drivers avec Docker
      • Flocker, Convoy, visent à intégrer une technologie de réplication
      • c’est un moyen, pas une solution : reste un outil pour configurer ce que l’on souhaite

DataOps

Aller plus loin

  • Le livre Mastering Docker, de Russ McKendrick et Scott Gallagher
  • les ressources présentes dans la bibliographie
  • la liste de Awesome Docker

Dockercraft : administrez vos containers dans Minecraft

Retours

  • Comment ça s’est passé ?
    • Difficulté : trop facile ? trop dur ? quoi en particulier ?
    • Vitesse : trop rapide ? trop lent ? lors de quoi en particulier ?
    • Attentes sur le contenu ? Les manipulations ?
    • Questions restées ouvertes ? Nouvelles questions ?
    • Envie d’utiliser Docker ? ou de le jeter à la poubelle ?

Bibliographie

Docker

  • McKendrick, Gallagher 2017 Mastering Docker - Second Edition

Pour aller plus loin

  • Miell,Sayers2019 - Docker in Practice

Cheatsheet

Ressources

DevOps

  • Krief - Learning DevOps - The complete guide (Azure Devops, Jenkins, Kubernetes, Terraform, Ansible, sécurité) - 2019
  • The DevOps Handbook

Linux

Linux - Intro, Admin, Réseau et scripting

Découvrir le système d’exploitation open source - pour les particuliers et les serveurs !

Slides de cours

  1. Introduction à Linux
  2. Linux administration
  3. Linux admin avancée et réseau
  4. Shell scripting

Feuilles d’exercices

  1. Feuille d’exercices 1 partie 1
  2. Feuille d’exercices 1 partie 2
  3. Feuille d’exercices 2 admin et réseau
  4. Feuille d’exercices 3 scripting

Corrections des exercices et bilan compétences

Pour quelques autres éléments et supports voir

Corrections exercices partie 1

Correction des exercices

6. Permissions

  • 6.1 : Faire touch xwing.conf puis ls -l xwing.conf pour analyser les proprietaires et permissions actuelles. Changer le proprietaire/groupe si necessaire avec chown padawan:padawan xwing.conf. Reverifier les modifications avec ls -l xwing.conf
  • 6.2 : touch private, puis chmod ugo-rwx private par exemple (on peut aussi le faire en plusieurs étapes)
  • 6.3 : chmod u+r private, puis chmod ug+w private, puis chmod +x private
  • 6.4 : chmod ugo-rwx private (ou chmod 000 private)
  • 6.5 : chmod 731 private (car rwx-wx--x s’écrit 731 en octal)
  • 6.6 : chmod go-rx /home/padawan
  • 6.7 : chmod -R o-rwx ~/documents par exemple
  • 6.8 : en tant que root : mkdir /home/r2d2, puis en tant que root : chown r2d2 /home/r2d2 puis chmod go-rx /home/r2d2 devrait suffir (eventuellement enlever le w aussi)
  • 6.9 : touch /home/r2d2/droid.conf puis par exemple cd /home/r2d2 et chown r2d2:droid ./droid.conf
  • 6.10 : (en étant dans /home/r2d2/) touch beep.wav boop.wav blop.wav puis chown r2d2 *.wav et, par exemple, chmod go-x *.wav et chmod u+x *.wav
  • 6.11 : mkdir secrets puis touch secrets/nsa.pdf (eventuellement mettre du texte dans secrets/nsa.pdf). Ensuite : chmod -r secrets/ desactive le listage des fichiers dans secrets/ … pourtant, il est possible de faire cat secrets/nsa.pdf !
  • 6.12 : Si l’on essaye de faire un chown en tant que padawan, le système refusera ! (On ne peut pas donner ses fichiers à quelqu’un d’autre)
  • 6.13 : setfacl g:droid:r-x /home/padawan puis faire ls -l sur le dossier et constater le + à la fin des permissions. On peut regarder le détails des ACL avec getfacl /home/padawan
  • 6.14 : setfacl u:padawan:r-x /home/r2d2

7. Processus

  • 7.1 : Faire sleep 30 puis Ctrl+Z et bg pour mettre la commande en arrière plan. Constater que vous pouvez de nouveau taper des commandes. Faire jobs dans les secondes qui suivent et constater que la commande est toujours ‘Running’. Appuyer sur ‘Entrée’ régulièrement pendant les secondes qui suivent jusqu’à ce que ‘Done’ s’affiche.
  • 7.2 : Faire sleep 30 puis Ctrl+Z et bg pour mettre la commande en arrière plan. Constatez que vous pouvez de nouveau taper des commandes. Avant que la commande ne se termine (au bout des 30 secondes), faire fg pour récupérer la main sur le sleep puis faites Ctrl+C.
  • 7.3 : Faire sleep 30 & et constater que vous pouvez taper des commandes. Noter aussi que la console a affiché le PID du programme correspondant au sleep. Utiliser ce PID pour tuer le programme avec kill <PID>.
  • 7.4 : Lancer sleep 700000 (par exemple) puis faire ps -ef dans un autre terminal et constater que le processus est bien listé (vous pouvez aussi utiliser ‘top’ et les fleches)
  • 7.5 : Dans le ps -ef utiliser précédemment, vous pouvez trouver le PPID (parent PID) à côté du PID. Vous pouvez regarder dans le reste de la liste pour checher le programme correspondant à ce PPID (apriori il s’apelle ‘bash’).
  • 7.6 - Connaissant le PID du parent, utiliser kill <PID> ou kill -9 <PID> pour tuer le shell. Vous devriez constater que la session est détruite.
  • 7.7 - Lancez screen et dedans, sleep 30. Faites Ctrl+A puis D pour détacher la session. Eventuellement screen -list pour lister les sessions screen. Depuis un autre terminal, faites screen -r et constatez que vous récupérez bien le shell ou vous aviez lancé sleep 30.
  • 7.8 - Avec ps -ef ou ps -ef --forest, vous devriez voir le processus sleep 30 (ou relancez le si il a déjà terminé). Son parent devrait être un bash. Après avoir trouvé le PID de ce parent, faites kill -9 <PID> pour tuer cette session. Vous deviez constater que la session est détruite.
  • 7.9 - Lancer top : celui tout en haut consomme actuellement le plus de CPU. Si vous appuyez sur Shift+M, les programmes seront maintenant trié par utilisation de la RAM.
  • 7.10 - Lancer la commande openssl speed -multi 4, puis relancer top : vous devriez voir que 4 processus consomment maintenant beaucoup de CPU
  • 7.11 - Lancer nice -n 19 ls /bin : vous devriez voir que cette commande est trèèèès longue.
  • 7.12 - Identifier le PID des différent process openssl. Utiliser renice +10 <PID> pour changer leur niceness. En utilisant top, la colonnee ‘NI’ devrait maintenant indiquer une niceness différente de 0. Après avoir réduit la niceness de ces processus, relancer nice -n 19 ls /bin devrait être un peu plus rapide.
  • 7.13 - pkill openssl

8. Personnaliser son environnement

  • 8.1 : Un exemple de personnalisation de PS1 est :
PS1="[\033[01;32m\u on \h\033[0m:\033[01;34m\w\033[0m] \n> "
  • 8.2 : Ajouter la ligne précédente en bas de ~/.bashrc à l’aide de nano puis recharger avec source ~/.bashrc
  • 8.3 : Même chose que 8.2 mais en rajoutant une ligne comme :
echo "May the source be with you
  • 8.4 : Ouvrir /root/.bashrc avec nano (et possiblement sudo) puis rajouter une ligne pour modifier le PS1, comme :
PS1="[\033[01;31m\u on \h\033[0m:\033[01;34m\w\033[0m] \n> "

(noter la couleur ‘31’ = rouge)

  • 8.5 : Taper ll pour tester si la commande existe. Si elle n’existe pas, rajouter alias ll='ls -l' dans le bashrc puis le recharger avec source. Pour s’assurer que ls utiliser --color=auto par défaut, taper alias ls.
  • 8.6 : Taper alias suls='sudo ls -la' (par exemple) et alias sucat='sudo cat'. Tester en tant que padawan de taper suls /root et sucat /etc/shadow (ou d’autres dossiers / fichiers accessibles uniquement par root).
  • 8.7 : alias r2d2="sudo su r2d2" puis tester de taper r2d2.
  • 8.8 : Se renseigner sur Internet ;P (question un peu ‘extra’)
  • 8.9 : alias ls="echo 'G pas envie'"

9 partie 1 - redirections et assemblages

  • 9.1 : echo "hello, howdy ?!" > hello.txt
  • 9.2 : ls /usr/bin/ > files.tmplist puis less files.tmplist
  • 9.3 : (depuis votre home) mkdir ./dev; mkdir ./dev/bash; echo "Je fais du bash !" > ./dev/bash/intro
  • 9.4 : Mettre des calculs comme 6*7 ligne par ligne dans un fichier comme calc.txt puis lancer bc < calc.txt. On peut aussi faire bc <<< "6*7"
  • 9.5 : curl -L fr.wikipedia.org > wikipedia.html >/dev/null 2>&1 || echo "ça n'a pas marché !"
  • 9.6 :
touch /tmp/chat
chmod +w /tmp/chat
tail -f /tmp/chat &

puis faire echo "beep boop" >> /tmp/chat depuis d’autres terminaux (attention, il y a deux chevrons !).

Il est possible de créer l’alias say qui parle dans le chat avec :

alias say="echo [$USER] >> /tmp/chat"

9 partie 2 - pipes et boîte à outils

  • 9.7 : utiliser alias grep pour verifier que l’alias existe, sinon ajouter alias grep="grep --color=auto" au .bashrc et le recharger.
  • 9.8 : cat /etc/passwd | grep "/bin/bash"
  • 9.9 : cat /etc/passwd | grep "/bin/bash" | tr ':' ' ' | awk '{print $1}' (on peut aussi utiliser awk -F:, ou la commande cut)
  • 9.10 : cat /etc/passwd | grep "nologin$" | tr ':' ' ' | awk '{print $1}'
  • 9.11 : Les utilisateurs n’ayant pas de mot de passe sont typiquement caractérisés par un :x: sur la ligne (ou eventuellement un :!:) dans /etc/shadow. On utilise alors un grep ‘inversé’ (-v) pour obtenir les lignes des utilisateurs qui ont vraiment un mot de passe. On utilise aussi un “ou” dans grep (avec \|) pour ignorer à la fois les lignes contenant :!: et :x:.
sudo cat /etc/shadow | grep -v ":\!:\|:x:" | awk -F: '{print $1}'
  • 9.12 :
alias esquecestleweekend='date | grep "^Sat \|^Sun " >/dev/null && echo "Cest le weekend" && echo "Cest le weekend" || echo "Il faut encore taffer!"
  • 9.13 : Les lignes vides correspondent à ^$ (début de ligne suivi de fin de ligne) donc : cat /etc/login.defs | grep -v "^$" Pour enlever également les commentaires, on utilise un “ou” dans grep (\|), ce qui donne : cat /etc/login.defs | grep -v "^$\|^#"
  • 9.14 : dpkg-query --status vim | grep -q 'Status: install ok installed' && echo Oui || echo Non
  • 9.15 : grep -nr "daemon" /etc/
  • 9.16 : Similaire à la question 9.14 : who | grep -q r2d2 && echo "R2d2 est là !" || echo "Mais que fais r2d2 ?!"
  • 9.17 : ps -ef | grep -v "UID" | awk '{print $1}' | sort | uniq -c
  • 9.18 : cat loginattempts.log | awk '{print $9}' | sort | uniq -c | sort -n
  • 9.19 : Il s’agit d’un exercice un peu avancé avec plusieurs solutions possibles (qui ne sont pas trop robuste, mais peuvent dépanner). En voici une qui envoie les adresses des images dans un fichier img.list :
curl yoloswag.team           \
 | grep "img src"            \
 | sed 's/img src/\n[img]/g' \
 | grep "\[img\]"            \
 | tr '<>"' ' '              \
 | awk '{print $2}'          \
 > img.list

Corrections exercices partie 2

Gestion des archives

  • 1.20 - Créez une archive (non-compressée !) de votre répertoire personnel avec tar.
tar -cvf monhome.tar /home/mon_utilisateur
  • 1.21 - En utilisant gzip, produisez une version compressée de l’archive de la question précédente
gzip monhome.tar
# Ensuite on trouve monhome.tar.gz qui a une taille reduite
# comparé à avant
  • 1.22 - Recommencez mais produisant une version compressée directement
tar -cvzf monhome.tar.gz /home/mon_utilisateur
  • 1.23 - En fouillant dans les options de tar, trouvez un moyen de lister le contenu de l’archive
tar -tvf monhome.tar
  • 1.24 - Créez un dossier test_extract dans /tmp/, déplacez l’archive dans ce dossier puis décompressez-là dedans.
mkdir /tmp/test_extract
mv monhome.tar.gz /tmp/test_extract
cd /tmp/test_extract
tar -xvzf monhome.tar.gz ./
  • 1.25 - TODO

  • 1.26 - Il existe des fichiers de logs g-zippés comme /var/log/apt/history.log.1.gz (si vous avez fait quelques commandes avec apt). Il contient l’historique des opérations récentes effectuées avec apt. Ou encore : /var/log/dmesg.1.gz (si votre machine a déjà démarré plusieurs fois) qui contient les historiques de démarrage du système. On peut faire find /var/log -name "*.gz" pour trouver tous les fichiers de log zippés. Si l’on utilise uniquement cat /var/log/apt/history.log.1.gz, le résultat n’est pas lisible car il s’agit d’un flux binaire. Il est néanmoins possible de le dézipper “à la volée” en pipant le résultat dans gzip :

cat /var/log/apt/history.log.1.gz | gzip -d

Ou bien il existe une commande zcat qui fait cette opération directement :

zcat /var/log/apt/history.log.1.gz

Corrections exercices partie 3

Partie 1 - les variables

#!/bin/bash

DISTRIB=$(cat /etc/os-release \
        | grep PRETTY_NAME \
        | awk -F= '{print $2}' \
        | tr -d '"')

NB_PROCESS=$(ps -ef --no-headers \
           | wc -l)

RAM_TOTALE=$(free -h | grep "^Mem" | awk '{print $2}')
RAM_DISPO=$(free -h | grep "^Mem" | awk '{print $7}')

UPTIME=$(uptime --pretty)
IP_LOCALE=$(ip a | grep "inet " | grep -v "127.0.0.1" | awk '{print $2}' | awk -F/ '{print $1}')

IP_GLOBALE=$(curl --silent ip.yunohost.org)

echo "La distribution est $DISTRIB"
echo "Il y a $NB_PROCESS process actuellement lancés"
echo "Il reste $RAM_DISPO RAM dispo sur $RAM_TOTALE total"
echo "La machine est up depuis $UPTIME"
echo "L'IP locale est $IP_LOCALE"
echo "L'IP globale est $IP_GLOBALE"

RED="\033[31m"
GREEN="\033[32m"
PURPLE="\033[35m"

echo -e "${RED}How ${GREEN}are ${PURPLE}you?"

2 - Paramétrabilité, interactivité

2.2 (add)

#!/bin/bash

RESULTAT=$(($1 + $2))

echo $RESULTAT

### 2.3 (age)

#!/bin/bash

CURRENT_YEAR=$(date +%Y)

echo -e "En quelle année est-tu né ? "
read YEAR
AGE=$(($CURRENT_YEAR-$YEAR))
echo "Tu as $AGE ans!"

2.4 (check_user)

#!/bin/bash

USER="$1"

HOME_USER=$(cat /etc/passwd | grep "^$USER:" | awk -F: '{print $6}')

ESPACE_DISQUE=$(du -hs $HOME_USER | cut -f1)

NB_PROCESS=$(ps au -u $USER --no-headers | wc -l)

NB_TERM=$(ps au -u $USER | grep bash | wc -l)

echo "L'utilisateur utiliser $ESPACE_DISQUE pour son home $HOME_USER"
echo "L'utilisateur a $NB_PROCESS processus en cours"
echo "    dont $NB_TERM terminaux bash"

Bilan compétences Linux

Utilisation du terminal

  • Savoir taper une commande, identifier les morceaux importants : nom de commande, options, arguments
  • Savoir identifier dans quel répertoire on se trouve actuellement, avec quel user, et sur quelle machine
  • Savoir utiliser l’auto-complétion et l’historique
  • Savoir obtenir de l’aide sur une commande
  • Savoir relire attentivement sa commande pour vérifier les typos
  • Savoir lire attentivement ce que la commande renvoie pour valider qu’elle a fonctionné … ou bien qu’il y a une erreur à debugger

Fichiers

  • Comprendre la notion de chemin relatif et de chemin absolu pour désigner un fichier
  • Où sont stockés les fichiers de configuration
  • Où sont stockés les programmes
  • Où sont stockés les logs
  • Où sont les répertoires utilisateurs
  • Savoir afficher ou éditer un fichier depuis la ligne de commande

Users

  • Savoir lister les users et groupes
  • Savoir créer un user
  • Savoir ajouter un user dans un groupe et listers les groupes dans lequel un user est
  • Savoir lire les permissions r/w/x d’un fichier, et les modifier
  • Savoir identifier le propriétaire + groupe propriétaire d’un fichier, et le modifier
  • Savoir changer son mot de passe
  • Savoir executer des taches d’administration avec sudo
  • Savoir changer de compte utilisateur avec su

Processus

  • Voir les processus qui tournent actuellement
  • Savoir identifier le proprietaire d’un process et son PID
  • Comprendre les relations de parentés entre process
  • Savoir tuer un process
  • Comprendre qu’il existe un process “originel” nommé “init”

Installation de Linux

  • Avoir compris la procédure d’installation de linux :
    • téléchargement d’une ISO,
    • boot sur l’ISO,
    • configuration des partitions et points de montage
  • Comprendre la notion de point de montage d’une partition
  • Savoir monter manuellement un périphérique de stockage externe

Gestionnaire de paquet

  • Savoir installer un paquet
  • Savoir mettre à jour le système
  • Savoir ce qu’est un dépot de logiciel
  • Savoir ajouter un dépot de logiciel (et clef de signature associée)

Réseau (IP)

  • Comprendre que l’acheminement des paquets sur le réseau se fait par des routeurs qui discutent entre eux pour optimiser les trajets
  • Comprendre la notion de réseau local
  • Savoir qu’il y a l’IPv4 … mais aussi l’IPv6 !
  • Savoir identifier son IPv4 locale
  • Savoir identifier son IPv4 globale
  • Savoir pinger une autre machine

Réseau (TCP)

  • Comprendre que TCP est une couche réseau qui permet d’introduire de la fiabilité dans les communications à l’aide d’accusé de réceptions
  • Comprendre qu’il est nécessaire d’introduire la notion de port (en plus de l’IP) pour spécifier entre quelles programmes se fait une communication TCP
  • Savoir lister les process qui écoutent sur un port
  • Savoir ce qu’est un firewall et de quoi il protège

Réseau (DNS)

  • Savoir ce qu’est un nom de domaine
  • Savoir résoudre un nom de domaine
  • Savoir ce qu’est un résolveur DNS, et où il est configuré sur le système

Réseau (web)

  • Comprendre ce qu’il se passe au niveau réseau lorsqu’on visite une page web (résolution DNS, établissement d’une communication TCP, envoi d’une requête GET /)
  • Savoir télécharger des pages web ou fichiers sur le web avec wget ou curl

Notions de sécurité

  • Connaître les bonnes pratiques de base : tenir son serveur raisonnablement à jour, utiliser des mots (ou phrases) de passes raisonnablement forts
  • Comprendre pourquoi il ne faut pas faire chmod 777, ou chmod +r, notamment sur des fichiers contenant des informations privées (données personnelles) ou critique (mot de passe de base de donnée)
  • Comprendre qu’un serveur sur internet est sujet à des attaques automatiques, et qu’il est possible de mettre en place des contre-mesures
  • Comprendre le principe de la cryptographie asymétrique : notion de clef publique, clef privée
  • (idéalement : comprendre la notion d’authenticité et de signature cryptographique)

Infrastructure

  • Savoir qu’il est possible d’acheter des serveurs (VPS) en ligne (infrastructure as a service)

SSH

  • Savoir se connecter à une machine SSH, avec password ou clef
  • Savoir générer une clef publique / privée, et comment donner sa clef publique à un collègue
  • (idéalement : avoir compris l’intérêt d’utiliser une clef plutôt qu’un mot de passe)
  • Savoir jongler mentalement entre plusiers terminaux, possiblement connectés sur des machines différentes

Services

  • Savoir ce qu’est un service (au sens de l’administration système)
  • Savoir lancer / arrêter / redémarrer un service
  • Savoir afficher l’état d’un service
  • Savoir trouver et lire les logs d’un service
  • Comprendre que le déploiement d’une application implique généralement d’installer et configurer un écosystème de services qui travaillent ensemble : serveur web, “l’app”, et le serveur de base de donnée

Commandes “avancées”

  • Comprendre la notion de code de retour, d’entrée standard, sortie standard et erreur standard
  • Savoir rediriger les sorties des commandes
  • Savoir enchainer des commandes (;, &&, ||, |)
  • Savoir utiliser grep, awk, cut, sort, uniq, wc, … pour filtrer ou faire des calculs sur les sorties des commandes

Scripting bash

  • Savoir modifier et afficher une variable
  • Avoir compris le rôle du fichier ~/.bashrc
  • Avoir compris comment le shell sais où trouver les programmes correspondants aux commandes tapées (variable PATH)
  • Savoir écrire un script et le lancer
  • Savoir utiliser les arguments fourni dans un script
  • Savoir mettre la sortie d’une commande dans une variable
  • Savoir comment écrire un bloc de condition
  • Savoir écrire des fonctions, des boucles
  • Savoir ajouter une tâche planifiée sur le système (cron)
  • Savoir ne pas partir en courant à la vue d’une regex

Git et Gitlab

Git 1 - Introduction

GIT = Des dépôts de code à partager

Comment gérer du code logiciel ?

Plusieurs difficultés :

  1. Suivre le code avec précision :

    • Comme on l’a vu chaque lettre compte : une erreur = un bug qui peut être grave et nous faire perdre plusieurs heures
    • Mémoire : comment savoir ou l’on en était quand on revient sur le projet d’il y a deux mois
  2. Collaboration : Si on travaille à 15 sur un même programme :

    • Comment partager nos modifications ?
    • Comment faire si deux personnes travaillent sur le même fichier => conflits
  3. Version du logiciel :

    • Le développement est un travail itératif = contruction petit à petit => plein de versions !
    • On veut ajouter une nouvelle fonctionnalité à un logiciel, mais continuer à distribuer l’ancienne version et l’améliorer.
    • On veut créer une version de test pour que des utilisateur·trices avancé·es trouvent des bugs

Solution : un gestionnaire de versions

  1. Suit chaque modification faite à des fichiers, en général des fichiers texte (souvent de code mais peut être autre chose : de la documentation, par exemple en format Markdown comme ce cours, plus rarement d’autres fichiers, comme des documents Word).

  1. Permet de stocker plusieurs versions des mêmes fichiers et passer d’une version à l’autre.

Un peu comme la fonctionnalité “Historique” de Google Docs ou de Framapad en beaucoup plus avancé.

  1. Permet de suivre qui a fait quelle modification, partager les modifications avec les autres, régler les conflits d’édition

Git !

git est un petit programme en ligne de commande. Qui fait tout ce dont on vient de parler :

  • Suit les fichiers
  • Gère les modifications successives et leurs auteurs/autrices
  • Fait cohabiter plusieurs versions
  • Aide à résoudre les conflits de code

Pour la petite histoire, Git a été inventé en 2005 par Linus Torvalds, le créateur de Linux, pour garder la trace des propositions de modification du code de Linux !

Écosystème Git :

⚠️ A ne pas confondre !!!

  • le programme git : le gestionnaire de version = le coeur de l’écosystème => en ligne de commande
  • les interfaces graphique de git : VSCode et ses extensions, tig, meld, GitKraken, etc.
    • Pour faciliter l’utilisation de git et visualiser plus facilement
    • communique avec git sans le remplacer (ne fait que traduire vos clics de souris en commandes Git)
  • les forges logicielles basées sur Git comme github ou framagit:
    • des plateformes web pour accéder au dépôt de code (dossier) / mettre son code sur les internets.
    • faciliter la collaboration sur un projet
    • tester et déployer le code automatiquement comme dans la démarche DevOps (plus avancé)

On va utiliser les trois car c’est nécessaires pour bien comprendre comment on travaille avec git sur un projet.

On va utiliser :

  • git en ligne de commande souvent : il faut absolument connaître les fonctions de base pour travailler sur un projet de code aujourd’hui
  • VSCode : un éditeur de texte qui a des fonctions pratiques pour visualiser les modifications git et l’historique d’un projet, afficher les conflits d’édition.
  • Gitlab sur l’instance framagit.org : une forge logicielle open-source. On va l’utiliser pour collaborer sur du code existant. Framagit est l’instance de l’association Framasoft qui milite pour le libre et un Internet décentralisé.

Git, fonctionnement de base

Git est très simple d’utilisation pour les cas les plus simples, mais il a parfois un comportement inattendu car il utilise certains concepts parfois contre-intuitifs._

Mémoriser les commandes prend du temps

Utilisez votre memento !

  • On va utiliser les commandes de base durant les prochains jours pour se familiariser avec le fonctionnement normal.

  • En entreprise on utilise tout le temps git avec une routine simple. On y reviendra.

  • Même les ingénieur·es avec de l’expérience se trompent dans le comportement d’une commande Git et ne connaissent pas forcément les fonctions avancées.

1. Créer un nouveau dépôt git, valider une première version du code

Vous êtes dans un dossier avec du code :

  • git init crée un dépôt dans ce dossier (transforme un dossier simple en un dossier avec git d’initialisé)
  • git add permet de suivre certains fichiers (dire à git qu’il faut inclure la version actuelle de ce fichier dans git)
  • git commit permet de valider vos modifications pour créer ce qu’on appelle un commit, c’est-à-dire une étape validée du code.
  • git status et git log permettent de suivre l’état du dépôt et la liste des commits.

Le commit

Un commit est composé :

  • d’un message de commit

  • d’un instantané du code auquel on se réfère via un identifiant unique (une empreinte ou un hash)

  • d’un auteur / une autrice

  • de référence par rapport à un (ou des) commit parent (ce qui nous permet de faire des branches de l'arbre de Git)

  • to commit signifier s’engager

  • Idéalement, lorsque vous faites un commit, le code devrait être dans un état à peu près cohérent et le commit devrait rassembler des modifications qui ont du sens pour atteindre un objectif (par exemple : résoudre un bug, rajouter une fonctionnalité, modifier de la documentation…)

  • Toujours mettre un message de commit

  • Les commits sont des étapes du développement du logiciel. Lire la liste de ces étapes devrait permettre à un·e developpeur / développeuse de comprendre l’évolution du code.

  • un commit est toujours une référence à une version précise de l’ensemble du code par rapport à l’arbre Git, c’est n’est pas juste des ajouts et des suppressions par rapport au code du commit précédent

Créer un nouveau dépot : Démonstration !

Cycle des fichiers

Les différents espaces de Git :

  • l’espace de travail : ce sont les fichiers qu’il y a réellement dans votre dossier
  • l'index ou staging : un espace où l’on prépare son futur commit
  • et enfin l’arbre des commits définitif, avec HEAD qui fait référence au commit sur lequel on travaille

Premiers exercices


Git 1 - Exercices

Créer un projet git

Durant ces exercices nous allons utiliser Git en ligne de commande (sans interface graphique) : l’objectif est de pratiquer les différentes commandes de base git

Installer Git

git est souvent déjà installé sur Linux. Mais si ce n’est pas le cas, il suffit d’installer le paquet git, par exemple avec apt install git.

Initialiser le dépôt

  • En ligne de commande créez le dossier de code tp1_git.

  • Chargez ce dossier avec VSCode.

Sur Linux : Si VSCode n’est pas installé : snap install --classic code

  • Pour lancer VSCode : code ou code mondossier/

  • Créez un nouveau fichier Python dans ce dossier appelé multiplication.py. Copiez-y le code suivant :

Cliquer pour afficher `multiplication.py` :
  • Lancez git status. Quel est le problème ?
  • Initialisez le dépot de code avec la commande git init.
  • Utilisez ensuite git status pour voir l’état de votre dépôt.

Dire à Git de suivre un fichier

Pour le moment Git ne versionne aucun fichier du dépôt comme le confirme la commande git status.

  • Utilisez git add <nom_fichier> sur le fichier. Puis faites à nouveau git status. Le fichier est passé à l’état suivi (tracked).
  • Créez un nouveau fichier et écrivez quelque chose à l’intérieur (ou copiez un fichier situé en dehors de ce dossier vers ce dossier).
  • Faites git status à nouveau. Que s’est-il passé ?

Faire votre premier commit

  • Faites git status pour constater que tous les fichiers sont non suivis sauf un.
  • Un commit est une version du code validée par un·e développeur/développeuse. Il faut donc que git sache qui vous êtes avant de faire un commit. Pour ce faire, utilisez :
git config --global user.name "<votre nom>"
git config --global user.email "<votre email>"
  • Pour créer un commit on utilise la commande git commit -m "<message_de_commit>" (commit signifie s’engager alors réfléchissez avant de lancer cette commande !). Utilisons le message "Ceci est mon premier commit" pour le premier commit d’un dépôt. Valider la version courante.
  • Lancez un git status pour voir l’état du dépôt. Que constate-t-on ?
  • Lancez git log pour observer votre premier commit.

Commit de tous les fichiers

  • Si le dossier __pycache__ n’a pas été créé, créez manuellement juste pour le TP un fichier : touch __pycache__

  • Utiliser git add avec l’option -A pour ajouter tous les fichiers actuels de votre projet.

  • Qu’affiche git status ?

  • Lancez à nouveau git commit avec un message adéquat.

  • A quoi sert le dossier __pycache__ ? Que faire avec ce dossier ?

Supprimer un fichier

Oh non ! Vous avez ajouté le dossier __pycache__ dans votre commit précédent 🙃 Ce ne serait pas correct de pousser sur Internet votre code en l’état !

  • Supprimez le suivi du dossier __pycache__ avec la commande git rm:
    • Quelles options sont nécessaires ? utilisez git rm --help pour les trouver.

Ignorer un fichier

Maintenant que nous avons supprimé ce dossier nous voulons éviter de l’ajouter accidentellement à un commit à l’avenir. Nous allons ignorer ce dossier.

  • Ajoutez un fichier .gitignore et à la première ligne ajoutez __pycache__
  • Ajoutez ce fichier au suivi.
  • Ajoutez un commit avec le message “ignore __pycache__
  • Lancez le programme multiplication.py à nouveau.
  • Lancez status. Que constate-t-on ?

Annuler un ou plusieurs commit

Le problème avec la suppression de __pycache__ de la partie précédente est qu’elle n’affecte que le dernier commit. Le dossier inutile __pycache__ encombre encore l’historique de notre dépôt.

  • Pour le constater, installez l’extension Git Graph de VSCode.

  • Explorer la fenêtre git graph en cliquant sur Git Graph en haut à gauche de la fenêtre des fichiers.

  • Regardez successivement le contenu des deux commits.

  • Pour corriger l’historique du dépôt nous aimerions revenir en arrière.

  • Utilisez git reset avec HEAD~2 pour revenir deux commits en arrière (nous parlerons de HEAD plus tard).

  • Faites git status. Normalement vous devriez avoir un seul fichier non suivi .gitignore. Git vient de réinitialiser les ajouts des deux commits précédents.

  • Constatez dans Git Graph que seul reste le premier commit qui est toujours là.

  • Ajouter et committez tous les fichiers non suivis du dépôt.

  • Vérifier que __pycache__ n’apparaît pas dans l’historique.

Exercices supplémentaires

gitexercises.fracz.com

  1. https://gitexercises.fracz.com/exercise/master
  2. https://gitexercises.fracz.com/exercise/commit-one-file
  3. https://gitexercises.fracz.com/exercise/commit-one-file-staged
  4. https://gitexercises.fracz.com/exercise/ignore-them
  5. https://gitexercises.fracz.com/exercise/remove-ignored

Git 2 - Explorer un dépôt

Il s’agit de télécharger le dépôt d’un logiciel depuis Internet en créant un dossier contenant le code ainsi que son historique Git:

  • git clone <url dépot> puis cd <dépôt> pour aller dans le dossier du dépôt.

    • par exemple git clone https://github.com/YunoHost/gertrude/ et cd gertrude,
    • ou bien https://github.com/spring-projects/spring-petclinic et cd spring-petclinic
    • ou encore https://github.com/miguelgrinberg/microblog et cd microblog
  • git log pour voir la liste des commits

  • git checkout <commit num> pour vous déplacer au niveau d’un commit : le code dans le dépôt change.

  • git diff <commit_1> <commit_2> pour voir ce qui a changé entre deux commits.

  • Plus pratique : utilisez VSCode et Git Graph

Un dépôt Git téléchargé depuis Internet peut être privé : il faut alors se connecter avant à son compte (en HTTP ou SSH) pour le télécharger. Quand on veut modifier le dépôt distant (ajouter des commits), il faut de toute façon se connecter à un compte.

L’historique d’un dépôt

master et les branches d’un dépôt

  • Un dépôt git permet d’avoir plusieurs historiques en parallèle qu’on appelle des branches. Un dépôt git ressemble à un arbre.

  • La branche principale s’appelle master dans git (par convention), parfois main.

  • Ça commence à devenir compliqué ! Mais on va souvent travailler avec seulement deux branches 😌

  • master + une branche pour votre travail en cours.

Remonter le temps, déplacer HEAD

  • Si git mémorise les commits successifs du dépôt c’est en particulier pour permettre de “remonter le temps”, c’est-à-dire remettre le code du dépôt dans un état antérieur.

    • git checkout <commit>. L’historique se met également à jour.
    • git diff permet à tout moment d’afficher les différences entre deux points du dépôt.
  • Dans git, HEAD désigne un curseur qui indique dans quel état est le dépôt actuellement.

    • par défaut HEAD pointe sur le dernier commit de la branche (master s’il n’y en a qu’une).
    • remonter le temps cela signifie déplacer HEAD.
    • git reflog affiche l’historique des déplacements de HEAD.

Déplacer HEAD dans l’historique

Interface graphique pour explorer l’historique d’un dépôt.

Plusieurs éditeurs de code proposent des interfaces graphique pour :

  • naviguer dans les modifications d’un dépôt.
  • comparer plusieurs états du dépôt.

C’est le cas de VSCode, en particulier avec l’extension Git Graph

D’autres interfaces pratiques et indépendantes de l’éditeur : tig, meld, …

  • Installer Git Graph dans VSCode si ce n’est pas déjà fait

Utiliser les commandes git reset et git reset --hard

Attention: git reset --hard peut vous faire perdre votre travail s’il n’est pas dans un commit !!!

  • git reset : réinitialiser le HEAD au commit indiqué en gardant les modifications.
  • git reset --hard : réinitialiser le HEAD au commit indiqué en perdant les modifications

Deuxième partie des exercices

Git 2 - Exercices

Durant cette partie nous allons explorer un dépôt git existant grâce aux commandes git de base mais également grâce au GUI (interface graphique) de VSCode.

Récupérer un dépôt de code

Il s’agit d’un dépôt exemple d’une application de microblogging (comme Twitter) codée en Python avec le framework Flask.

Explorer le dépôt

  • Plutôt que d’utiliser la version finale de l’application, remontons l’historique du dépôt pour retrouver un état plus simple de l’application.

  • Quel est le premier commit du dépôt ? A quoi sert-il ?

  • Utilisez la commande git blame sur le fichier app/main/routes.py. Cette commande est très utile quand on travaille à plusieurs car elle permet de savoir à qui s’adresser lorsqu’on cherche à comprendre le code ou qu’on a trouvé un bug.

  • Installez l’extension VSCode suivante pour explorer le dépôt depuis VSCode :

  • À l’aide de l’extension VSCode cherchez le premier commit de l’historique qui ne fasse pas référence à Redis : c’est le commit de la version v0.21 avant la version v0.22

  • Déplacez vous au niveau de ce commit avec git checkout <num_commit>. Votre dépôt est en mode “HEAD détaché” c’est à dire que le pointeur HEAD se balade le long de l’historique. C’est un état anormal dans lequel il ne faut généralement pas modifier le code. Il est très facile de se perdre dans un dépôt git (le cas échéant utilisez git reflog pour bien comprendre les opérations qui vous ont amené dans l’état courant).
  • Lancez à nouveau l’application avec la commande flask run

  • Utilisez l’application en visitant l’adresse http://localhost:5000/

  • On observe que la fonctionnalité d’export de posts qui était cassée n’existe plus

  • Utilisez git reflog pour observer les déplacement de votre pointeur HEAD.

Créer une branche pour étendre l’application

Nous allons maintenant créer une branche en repartant du début du projet pour étendre l’application avec une page supplémentaire “A propos”.

  • Installez dans VSCode l’extension Git Graph.

  • Retournez à la fin de l’historique du projet comme précédemment (master).

  • Nous allons expérimenter de réinitialiser (violemment) le projet au début de son historique avec git reset --hard. Réinitialisez au niveau du commit identifié précédemment. Constatez sur Git Graph que les commits on été effacés et les fichiers également (sans le --hard les commits auraient disparu mais les fichiers et leur contenus auraient été gardés et désindexés comme dans la partie 1).

  • La commande précédente a effacé toutes les modifications du dépôt des 106 derniers commits. Faites bien attention avec cette commande git reset --hard ! Dans notre cas ce n’est pas un problème car ces commits sont disponibles sur le serveur. Pour récupérer les commits effacés utilisez git pull. pull va récupérer les modifications depuis le serveur.

  • Créez une nouvelle branche avec git checkout -b <nom branche> appelez-la about-page.

  • Trouvez comment ajouter une page A propos à l’application Flask (indice : il faut ajouter une route, un template et un lien dans le menu).

Solution :
  • Une fois vos modifications ajoutées, faites simplement git diff. Cette fonction affiche en vert le code que vous venez d’ajouter, et en rouge celui que vous avez retiré, si jamais.

  • Ajoutez les fichiers modifiés (git add) et committez toutes ces nouvelles modifications.

  • Maintenant que les modifications sont engagées (commitées) refaites git diff. Que se passe-t-il ?

  • Trouvez comment faire pour comparer avec un autre commit pris au hasard en utilisant git diff.

  • Avec git diff toujours, comparez maintenant deux branches.

  • Utilisez git reset HEAD~1 pour annuler le dernier commit puis refaites-le en utilisant l’interface graphique de VSCode.

Exercices supplémentaires

gitexercises.fracz.com

https://gitexercises.fracz.com/exercise/fix-typo https://gitexercises.fracz.com/exercise/commit-lost

Git 3 - Les branches

Collaborer à l’aide des branches

Nous avons pour l’instant utilisé Git sur une seule branche : nos commits représentent une ligne qui va du commit le plus ancien au commit le plus récent.

Mais la force de Git est le concept d’arborescence (d’arbre) constituée de branches.

Théoriquement, une branche n’est qu’un pointeur vers un commit, une sorte de raccourci vers un commit particulier, qui est mise à jour à chaque fois que l’on crée un nouveau commit sur telle branche.

Créer une branche et basculer sur une branche

Créer une branche se fait avec la sous-commande checkout et l’option -b : git checkout -b <nom_de_branche> Si la branche existe déjà, il suffit d’utiliser git checkout suivi du nom de branche : git checkout <nom_de_branche>

Les tags

  • Les tags sont comme des raccourcis vers un commit précis.
  • En général on ne les modifie pas après les avoir créés.
  • Ils servent souvent pour faire référence au commit précis qui définit la version du code.

Cycles de développement

Il existe plusieurs méthodes d’organisation dans Git par rapport à l’utilité des branches

  • parfois il y a une branche stable et une branche development qui représente une version plus beta de l’application
  • il y a souvent des branches pour chaque fonctionnalité ajoutée, appelées feature branch

git-flow, le workflow le plus ancien, un peu trop complexe

L’exemple du GitHub flow

  • c’est le Git flow le plus simple, on a :
  • une branche master
  • des feature branch pour chaque fonctionnalité en développement

Git pour collaborer…

Merge et rebase

Parfois il faut donc utiliser quelques commandes plus avancées de Git pour expliquer aux gens lisant l’historique Git quand on a voulu raconter que :

  • deux versions du code ont été fusionnées (merge, fusion en anglais)
  • ou bien des modifications doivent être ajoutées (“rebasées”) sur la dernière version du code (rebase)

Réécrire l’historique

L’historique Git, c’est un peu raconter une histoire de comment on est arrivé à ce bout de code, ajouté pour telle fonctionnalité à telle version du logiciel.

Pour arriver à cela il y a 2 outils importants :

  • git cherry-pick <commit> : prend un commit et l’ajoute à la branche actuelle
  • le rebase interactif

Le rebase interactif

Le rebase interactif est un outil un peu compliqué à manipuler, qui nous permet de réécrire l’historique d’une branche en choisissant quels commits on va fusionner ensemble, effacer, ou réordonner. C’est la commande git rebase -i

L’article suivant, extrêmement riche, est une référence à laquelle on peut revenir en cas de doute sur le choix de merge ou de rebase : Bien utiliser Git merge et rebase, par Delicious Insights


Git 3 - Exercices

Les branches

Maîtriser les commandes Git

Learn Git branching

Merge

Les fusions de branche peuvent s’effectuer en local sur la machine ou sur la forge logicielle.

Prendre le TP microblog (à cloner si nécessaire depuis https://github.com/uptime-formation/microblog) et localiser la branche qui ajoute une page “A propos”. Faire un merge de cette branche avec master en local.

Rebase

Prendre le TP microblog et localiser la branche qui ajoute une page “A propos” (à cloner si nécessaire depuis https://github.com/uptime-formation/microblog).

  • Faire un rebase de cette branche sur master ou sur la branche de votre choix.
  • Faire un rebase de cette branche (ou d’une autre) sur master en mode interactif.

Exercices supplémentaires

  1. https://gitexercises.fracz.com/exercise/chase-branch
  2. https://gitexercises.fracz.com/exercise/change-branch-history
  3. https://gitexercises.fracz.com/exercise/merge-conflict
  4. https://gitexercises.fracz.com/exercise/save-your-work
  5. https://gitexercises.fracz.com/exercise/fix-old-typo
  1. https://gitexercises.fracz.com/exercise/commit-parts
  2. https://gitexercises.fracz.com/exercise/pick-your-features

Interactive rebase

  1. https://gitexercises.fracz.com/exercise/split-commit
  2. https://gitexercises.fracz.com/exercise/too-many-commits
  3. https://gitexercises.fracz.com/exercise/rebase-complex
  4. https://gitexercises.fracz.com/exercise/invalid-order

Bisect (avancé)

https://gitexercises.fracz.com/exercise/find-bug

Git 4 - Forges Git

Collaborer à l’aide de gitlab

Git pour collaborer…

Git devient indispensable lorsque :

  • L’équipe avec laquelle vous collaborez est grande…
  • Changeante…
  • Le logiciel évolue dans le temps et en taille.

La forge logicielle

  • Github.com
    • … est une forge logicielle en forme de réseau social.
  • Gitlab
    • … est une forge logicielle concurrente, et qui est open source : on peut en installer sa propre instance (ex: framagit.org). La plus grosse instance Gitlab est gitlab.com.

La merge request / pull request

  • merge requests : valider du code à plusieurs

  • git fetch : récupérer la dernière version du dépôt distant (sans rien changer à son dépôt local)

  • git pull : récupérer la dernière version de la branche actuelle depuis le dépôt distant (bouge le HEAD)

  • git push : envoyer la dernière version locale de la branche actuelle jusqu’au dépôt distant (bouge le HEAD distant, en d’autres termes modifie origin/HEAD)

CI/CD

L’intégration continue : s’assurer automatiquement de la qualité du code, à chaque commit poussé sur une forge. Le déploiement continu : déployer automatiquement une nouvelle version du code quand un commit est poussé sur une forge (sur la branche master ou deploy en général).

  • Gitlab a sa version intégrée de la CI, Gitlab CI
  • Github a sa version intégrée de la CI, Github Actions, mais historiquement on devait plutôt se baser sur un outil de CI séparé (Jenkins, Travis CI, etc.)

Git 4 - Exercices

Développer de façon collaborative avec la forge logicielle Gitlab

Créer un compte sur Gitlab et pousser un projet

Workflow

  • Pour chaque ajout le code sera :
    • Ajouté dans une nouvelle branche.
    • Poussé sur un projet Gitlab partagé.
  • Le code sera revu par la personne qui n’a pas codé grâce à une merge request puis sera fusionnée (merged) dans la branche master.
  • La personne qui n’a pas codé récupère la dernière version du code grâce à git pull

Merge

Les fusions de branche peuvent s’effectuer en local sur la machine ou sur la forge logicielle.

Exercice sur Microblog

  • Clonez le dépôt “microblog” indiqué par le formateur
  • On se propose maintenant de créer une branche pour étendre l’application avec une page supplémentaire “A propos”. Pour ce faire, commencez par créer une branche nommée about-page et vous positionner dessus.
  • Trouvez comment ajouter une nouvelle page “A propos” dans l’application. Il vous faudra ajouter un controlleur dans app/main/routes.py, un template dans app/templates/about.html, et un nouveau lien dans app/templates/base.html. Par exemple:
### Dans routes.py

@bp.route('/about')
def about():
    return render_template('about.html')
<!-- Dans about.html -->

{% extends "base.html" %}

{% block app_content %}
<h1>About</h1>

This is a simple microblogging app
{% endblock %}
<!-- Dans base.html (à l'endroit approprié) -->

<li><a href="{{ url_for('main.about') }}">{{ _('About') }}</a></li>
  • Commitez l’ensemble de ces changements (n’oubliez pas d’ajouter les nouveaux fichiers non-versionnés avec git add si besoin !)

Les remotes, les merges, les merge-request

  • Rendez-vous sur le dépôt original de microblog, puis forkez le projet à l’aide du bouton en haut à droite de la page
  • Ajoutez ce nouveau remote dans votre clone local à l’aide de git remote add
  • Poussez votre branche about-page sur votre fork
  • Confirmez que vous trouvez bien cette nouvelle branche sur votre fork depuis votre navigateur, puis allez dans la partie “Merge request”. Créez une nouvelle “merge request” en prenant bien soin de sélectionner la branche du formateur (sur le dépôt original !) comme cible.
  • Vérifiez que la merge request a bien été crée sur le dépôt du formateur et est en attente de relecture/validation
  • Pendant ce temps, le formateur continue de travailler sur sa branche main et va bientôt commiter un changement qui va créer un conflit entre main et votre branche (attendre le signal du formateur ;)). Une fois que c’est fait, vous devriez voir sur la page de la merge request qu’une vérification de mergeabilité effectuée par GitLab est passée au rouge.
  • Utilisez git pull (ou bien git fetch et git merge séparément) pour fusionner la branche du formateur dans la votre, et résolvez le conflit. Poussez ensuite le nouveau commit sur votre branche et validez que la vérification de Gitlab est repassée au vert.
  • Le formateur devrait également avoir laissé une petite revue de code contenant une suggestion de changement. Utilisez l’interface de GitLab pour transformer cette suggestion en commit, et synchronisez de nouveau votre branche locale. Vérifiez que la suggestion du formateur est bien présente dans la sortie de git log ou dans Git Graph de VSCode.
  • Une fois que le formateur a mergé votre merge-request (ou celle d’un.e camarade !), re-synchronisez votre dépôt local ainsi que votre fork.

Exercices sur Learning Git Branching

  • Sur Learn Git branching, cherchez la section “Remote” et lancez “Push & Pull – dépôts gits distants !” (ou bien level remote1)

Ressources

Git 5 - Les pipelines avec Gitlab CI

La CI/CD

(intégration continue et déploiement continu)

  • Accélérer la livraison des nouvelles versions du logiciel.

  • Des tests systématiques et automatisés pour ne pas se reposer sur la vérification humaine.

  • Un déploiement progressif en parallèle (Blue/Green) pour pouvoir automatiser le Rollback et être serein.

  • A chaque étape le code passe dans un Pipeline de validation automatique.

La CI/CD fait partie de l’approche DevOps dont fait aussi partie les concepts de cloud (Infrastructure-as-a-Service, IaaS), d’Infrastructure-as-Code et les conteneurs.

Le Cloud (plus précisément : Infrastructure-as-a-Service, ou IaaS)

Plutôt que d'installer manuellement de nouveaux serveurs linux pour faire tourner des logiciels on peut utiliser des outils pour faire apparaître de nouveaux serveurs à la demande.

Du coup on peut agrandir sans effort l’infrastructure de production pour délivrer une nouvelle version

C’est ce qu’on appelle le IaaS (Infrastructure as a service)

Cloud et API

Dans le cloud, à la demande signifie que les vendeurs de cloud fournissent une API (REST généralement) Pour contrôler leur infrastructure.

  • Une API est un ensemble de fonctions qu’on peut appeler en codant.
  • Une API REST (assez simple et très populaire depuis) est une API qui permet de discuter sur le web avec des informations décrite dans le format JSON.

Exemple pour Scaleway: https://developer.scaleway.com/

Infrastructure As Code

Avantages :

  • On peut multiplier les machines (une machine ou 100 machines identiques c’est pareil).

  • Git ! gérer les version de l’infrastructure et collaborer facilement comme avec du code.

  • Tests fonctionnels (pour éviter les régressions/bugs)

  • Pas de surprise = possibilité d’agrandir les clusters sans soucis !

Les conteneurs

  • La nature facile à déployer des conteneurs et l’intégration du principe d’Infrastructure-as-Code les rend indispensable dans de la CI/CD (intégration continue et déploiement continu).
  • Les principaux outils de CI sont Gitlab, Jenkins, Github Actions, Travis CI…
    • Gitlab propose par défaut des runners préconfigurés qui utilisent des conteneurs Docker et tournent en général dans un cluster Kubernetes.
    • Gitlab propose aussi un registry d’images Docker, privé ou public, par projet.


Ressources

Essentiel :

Get started with GitLab CI/CD : https://docs.gitlab.com/ee/ci/quick_start/

La syntaxe Gitlab CI

Documentation de référence de .gitlab-ci.yml : https://docs.gitlab.com/ee/ci/yaml/


Exemples

Exemple de pipeline :

build-job:
  stage: build
  script:
    - echo "Hello, $GITLAB_USER_LOGIN!"

test-job1:
  stage: test
  script:
    - echo "This job tests something"

test-job2:
  stage: test
  script:
    - echo "This job tests something, but takes more time than test-job1."
    - echo "After the echo commands complete, it runs the sleep command for 20 seconds"
    - echo "which simulates a test that runs 20 seconds longer than test-job1"
    - sleep 20

deploy-prod:
  stage: deploy
  script:
    - echo "This job deploys something from the $CI_COMMIT_BRANCH branch."

Exemple avec du code Ruby :

stages:
  - build
  - test

build-code-job:
  stage: build
  script:
    - echo "Check the ruby version, then build some Ruby project files:"
    - ruby -v
    - rake

test-code-job1:
  stage: test
  script:
    - echo "If the files are built successfully, test some files with one command:"
    - rake test1

test-code-job2:
  stage: test
  script:
    - echo "If the files are built successfully, test other files with a different command:"
    - rake test2

Exemple réaliste avec Maven :


# Build JAVA applications using Apache Maven (http://maven.apache.org)
# For docker image tags see https://hub.docker.com/_/maven/
#
# For general lifecycle information see https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

# This template will build and test your projects
# * Caches downloaded dependencies and plugins between invocation.
# * Verify but don't deploy merge requests.
# * Deploy built artifacts from master branch only.

variables:
  # This will suppress any download for dependencies and plugins or upload messages which would clutter the console log.
  # `showDateTime` will show the passed time in milliseconds. You need to specify `--batch-mode` to make this work.
  MAVEN_OPTS: "-Dhttps.protocols=TLSv1.2 -Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=WARN -Dorg.slf4j.simpleLogger.showDateTime=true -Djava.awt.headless=true"
  # As of Maven 3.3.0 instead of this you may define these options in `.mvn/maven.config` so the same config is used
  # when running from the command line.
  # `installAtEnd` and `deployAtEnd` are only effective with recent version of the corresponding plugins.
  MAVEN_CLI_OPTS: "--batch-mode --errors --fail-at-end --show-version -DinstallAtEnd=true -DdeployAtEnd=true"

# This template uses jdk8 for verifying and deploying images
image: maven:3.3.9-jdk-8

# Cache downloaded dependencies and plugins between builds.
# To keep cache across branches add 'key: "$CI_JOB_NAME"'
cache:
  paths:
    - .m2/repository

# For merge requests do not `deploy` but only run `verify`.
# See https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html
.verify: &verify
  stage: test
  script:
    - 'mvn $MAVEN_CLI_OPTS verify'
  except:
    variables:
      - $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

# Verify merge requests using JDK8
verify:jdk8:
  <<: *verify

# To deploy packages from CI, create a ci_settings.xml file
# For deploying packages to GitLab's Maven Repository: See https://docs.gitlab.com/ee/user/packages/maven_repository/index.html#create-maven-packages-with-gitlab-cicd for more details.
# Please note: The GitLab Maven Repository is currently only available in GitLab Premium / Ultimate.
# For `master` branch run `mvn deploy` automatically.
deploy:jdk8:
  stage: deploy
  script:
    - if [ ! -f ci_settings.xml ];
        then echo "CI settings missing\! If deploying to GitLab Maven Repository, please see https://docs.gitlab.com/ee/user/packages/maven_repository/index.html#create-maven-packages-with-gitlab-cicd for instructions.";
      fi
    - 'mvn $MAVEN_CLI_OPTS deploy -s ci_settings.xml'
  only:
    variables:
      - $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

Git 5 - Exercices

Configurer Gitlab CI

Dans le projet Microblog :

  • Ajoutons un template de CI Gitlab depuis la page web de Gitlab. Committons-le sur une branche template-ci
  • Depuis main, créez une nouvelle branche ajout-test-ci. Dans cette branche, rajoutez via un cherry-pick le commit que vous aurez trouvé dans une des branches (sur origin) qui rajoute le fichier .gitlab-ci.yml, contenant une sorte de Hello-World.
  • Rajoutez un nouveau job qui va installer l’outil flake8 et le lancer sur le fichier app/main/routes.py :
apt update
apt install python3-pip -y
pip3 install flake8
flake8 app/main/routes.py
  • Commitez vos changements, poussez votre branche sur votre fork, et créez une nouvelle pull-request. Constatez également que, normalement, la pipeline s’est déclenchée pour faire tourner le test.
  • Corrigez le fichier app/main/routes.py pour que flake8 soit content
  • Finalement, testons le fonctionnement de git rebase
    • Re-créez une toute nouvelle branche superbranche qui commencera depuis le tag v0.21
    • Utilisez des git cherry-pick pour ajouter votre (ou vos) commits qui rajoutait la page “About”
    • De même pour les commits qui rajoutaient la CI dans Gitlab
    • Regardez la structure actuelle des différentes branche dans VScode (ou avec git log --oneline --graph)
    • “Rebasons” votre branche de sorte à ce qu’elle démarre depuis le sommet de la branche main, en utilisant git rebase main
    • Comparez la nouvelle structure de branche

Ressources

Documentation

Vidéos

Issues, Merge Requests and Integrations in GitLab: https://www.youtube.com/watch?v=raXvuwet78M

Tutoriels

Code Refinery :

Cloud Consultancy Team :

Memento des commandes

Création d’un dépôt et ajout d’un commit

Commande Effet
git init <directory> Créer un dépôt git vide dans le répertoire spécifié ou initialise le répertoire courant en tant que dépôt git.
git config --global user.name <name> Définir le nom de l’auteur/autrice à utiliser pour les nouveaux commits.
git status Afficher l’état du dépôt et la liste des fichiers inclus ou non pour le prochain commit.
git add <dossier> Inclure (stage) tous les changement dans <dossier> pour le commit
git add <fichier> Inclure les changement du <fichier> pour le commit
git add -A Inclure tous les changements pour le commit
git rm <fichier> Enlever (unstage) <fichier> du prochain commit.
git diff Afficher les lignes modifiées depuis le dernier commit.
git commit -m "<message>" Valider les modifications sélectionnées (staged) pour créer un nouveau commit avec le message <message>.
git log ou git log --oneline --all --graph Afficher l’historique des commits
git remote add <name> <url> Ajouter une connexion de votre dépôt courant à un dépôt sur un serveur.
git push Pousser les nouveau commits sur le serveur (principal).

Téléchargement et exploration d’un dépôt simple

Commande Effet
git clone <url> Cloner en local un dépot depuis l’adresse <url> généralement un serveur ou un forge.
git pull Récupérer les dernières modification (#réflexe).
git log --oneline Afficher l’historique avec une ligne par commit.
tig Un outil plus sympa que git log pour explorer l’historique.
git diff HEAD <num_commit> Affiche la différence entre le commit actuel (HEAD) et le commit <num_commit>.
git diff HEAD HEAD~1 Affiche la différence entre le commit actuel (HEAD) et le précédent (HEAD~1).
git checkout <num_commit> Charge la version du code au niveau du commit <num_commit>. La “tête” se déplace au niveau de ce commit (HEAD détachée).
git checkout master ou <nom_branch> Positionne HEAD au niveau du dernier commit de la branche.
git reflog Affiche une liste des dernières positions de HEAD. (quand on est perdu !!! )

Les branches et les merges

Commande Effet
git branch Afficher la liste des branches
git branch <nom_branche> Créer une branche <nom_branche>
git checkout <nom_branche> Basculer sur la branche <nom_branche>
git switch <nom_branche> Basculer sur la branche <nom_branche>
git checkout -b <nom_branche> Créer une nouvelle branche et basculer dessus
git switch -c <nom_branche> Créer une nouvelle branche et basculer dessus
git diff <branche_1> <branche_2> Comparer deux branches pour voir les différences
git merge <nom_branche> Fusionner la branche <nom_branche> avec la branche courante.
git stash Sauvegarder ses modifications actuelles temporairement pour nettoyer son espace de travail.
git stash pop Réappliquer les modifications sauvegardées pour restaurer son espace de travail.

Corriger ses erreurs

Commande Effet
git commit --amend Ajouter des modifications au commit précédent pour le corriger ou simplement changer le message du commit précédent.
git reset <commit> Réinitialiser le HEAD au commit indiqué en gardant les modifications.
git reset --hard <commit> Réinitialiser le HEAD au commit indiqué en perdant les modifications.
git rebase <branche> (plus complexe) Reconstruire l’historique de la branche courant à partir d’une autre branche en résolvant les conflits à chaque commit
git branch -f <nom_branche> <commit> Réinitialiser la branche <nom_branche> (sur laquelle on n’est pas) au commit indiqué sans toucher à notre HEAD.
git restore <chemin_fichier> -s <commit> Récupère le contenu des fichiers indiqués par chemin_fichier extraits depuis le contenu du commit <commit>.

Lexique git

Concept Explication
Un commit Une version validée du code avec un auteur / une autrice, un message et un identifiant unique.
Une branche Une suite de commits avec un nom contenant une version du logiciel.
HEAD Le commit actuellement sélectionné dans le dépôt.
remote Un dépôt git sur un serveur par exemple la forge framagit.
origin Le nom du remote par défaut.
master La branche par défaut, généralement la branche principale.

Bibliographie

Liens

Ressources

Documentation

Théorie

Points précis

Extensions VSCode

Exercices

Tutos

Complets

Workflows

Feature branch workflow : https://coderefinery.github.io/git-collaborative/02-centralized/#centralized-workflow-exercise Github mais agnostique : https://github.com/foundersandcoders/git-workflow-workshop-for-two https://oesa.pages.ufz.de/git-exercises/exercise-4.html

Pipelines

Simples

Ressources

Vidéos

Issues, Merge Requests and Integrations in GitLab: https://www.youtube.com/watch?v=raXvuwet78M

QCM

Initiation à Git : questionnaire

Entourez la ou LES bonnes réponses.

Question 1

Qu’est-ce qu’un commit ?

  • A. Une étape validée du code qui apparaît dans l’historique du dépôt.
  • B. L’un des multiples historiques contenus dans un dépôt git.
  • C. N’importe quelle modification récente faite sur un des fichiers du dépôt.

Question 2

Comment connaître l’état courant d’un dépôt ?

  • A. git add
  • B. git checkout
  • C. git status
  • D. git branch

Question 3

Qu’est-ce que HEAD ?

  • A. Le serveur où on pousse son code.
  • B. Un curseur pointant sur un commit qu’on peut déplacer avec git checkout.
  • C. Une interface pour utiliser git.

Question 4

Une forge logicielle comme framagit est :

  • A. Une plateforme alternative qui remplace git.
  • B. Une plateforme pour partager du code en ligne.
  • C. Une plateforme de tutoriels pour apprendre la programmation.
  • D. Une plateforme utile pour collaborer en entreprise.

Question 5

Git permet de :

  • A. Gérer plusieurs versions du code d’un logiciel/script
  • B. Corriger automatiquement du code
  • C. Explorer l’historique du code d’un logiciel
  • D. Obtenir de l’aide sur la syntaxe en Python

Question 6

Où sont cachés les versions précédentes des fichiers dans git ?

  • A. Dans Gitlens.
  • B. Dans un dossier invisible .git pour chaque dépôt.
  • C. Dans le dossier /etc.

Question 7

Pour changer de branche on utilise:

  • A. git reflog <nom de la branche>
  • B. git checkout <nom de la branche>
  • C. git clone <nom de la branche>

Question 8

Habituellement, quel est le nom de la branche principale d’un dépôt ?

  • A. master
  • B. feature
  • C. main

Question 9

Une branche est :

  • A. Une nouvelle modification ajoutée à un dépôt
  • B. Une ligne d’historique du dépôt
  • C. Une opération de fusion

Question 10

Comment savoir quelles modifications ont été apportées lors du dernier commit ?

  • A. Utiliser git diff HEAD HEAD~1.
  • B. Utiliser gitLens dans VSCode avec la vue historique.
  • C. Utiliser Thonny pour debugger le code.

Question 11

Une merge request sert à :

  • A. Créer une discussion avec des collègues sur le code d’une fonction.
  • B. Faciliter la vérification collaborative du code.
  • C. Corriger automatiquement le code de votre nouvelle fonction.
  • D. Tester automatiquement le code ajouté.

Python

Bienvenue !

Vous trouverez sur ce site les supports de formations pour un module Python réalisé pour une POE à Rouen en juillet 2021.

Vous pouvez imprimer son contenu (page par page) en PDF à l’aide de la fonction d’impression de chromium qui donne de bons résultats.

Sans plus attendre vous pouvez démarrer par la page de mise en place de outils pour la formation

Introduction

Plan

Partie 1 : Notions de “base”

  • Variables, fonctions
  • Structures de contrôle (conditions, boucles)
  • Structures de données (listes, dictionnaires, …)
  • Debugging avec pdb/ipdb

Partie 2 : Notions avancés

  • Fichiers
  • Exceptions
  • Librairies
  • Bonne pratiques

Partie 3 : Programmation Orientée Objet

  • Classes et méthodes
  • Héritage et Polymorphisme
  • Encapsulation
  • Stockage de données?

Partie 4 : Python Object Model

  • Python Object Model, méthodes spéciales
  • Itérateurs, Décorateurs, Design Patterns
  • Modules et Packages, script CLI, documentation
  • Testing

Flask

Bonus

  • Regexp

Méthode

Alternance entre :

  • Des explications théoriques sur une notion donnée et présentation de syntaxes Python
  • Exercices pratiques que nous ferons ensemble pas à pas.

Tous est décrit sur le site.

Votre profil et vos attentes ?

Langage Python et programmation.

« L’Informatique »

Cuisiner de l’information

  • Préparer des outils et des ingrédients
  • Donner des instructions
  • … parfois en utilisant des “fonctions”
    • « monter des oeufs en neige »
    • « cuire à thermostat 6 pendant 20 minutes »

Langage de programmation

Comme un vrai langage !

  1. Concepts (mots, verbes, phrases …)
  2. Grammaire et syntaxe
  3. Vocabulaire
  4. Organiser sa rédaction et ses idées : structurer correctement son code et ses données

Le langage Python

  • “Moyen-niveau” : équilibre entre performance, flexibilité et simplicité d’écriture
  • Syntaxe légère, lisible, facile à prendre en main
  • Interprété, “scripting”, prototypage rapide
  • Flexible (typage dynamique, …)
  • Grande communauté, de plus en plus répandu…

Nous récapitulerons en conclusion les caractéristiques du langage, ses avantages et ses inconvénients.

Python history

« … In December 1989, I was looking for a “hobby” programming project that would keep me occupied during the week around Christmas. My office … would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python’s Flying Circus). » — Guido van Rossum

Some programming mindset

Remarque Meme
La programmation c’est compliqué
Il n’y a pas de honte à prendre du temps pour comprendre
Cassez des trucs !
Explorez !

Développement Logiciel

  • Jusqu’ici nous avons parlé du langage python et de la façon dont il permet d’exprimer un programme. Il s’agit donc de programmation.

  • Mais l’activité de coder va au delà de l’expression d’une logique dans un langage. Il s’agit d’organiser la production d’un ensemble d’élément de programme, un logiciel et pour cela on parle plutôt de développement logiciel.

Quatre grands thèmes de l’activité de développement

Algorithme / Langage / Architecture / Qualité Logicielle

Algorithme vs Langage

Lorsqu’on programme il est utile de faire la distinction en ce qui relève de :

  • L’algorithme c’est à dire de la logique de résolution de problème (indépendant du langage).
  • L’expression élégante de cet algorithme dans le langage qu’on veut utiliser.

Pour trouver un algorithme il vaut mieux dessiner et écrire sur un papier ce que l’on cherche à faire !

Architecture

Attitude du développeur

  • Il est important avoir des connaissances fondamentales (ce que je vous raconte ici notamment) et des connaissances techniques.

  • Il faut également avoir la recherche web facile pour pouvoir faire le tri dans la junglede tétails techniques.

Deux sources web classiques de l’information pertinente

  • github
  • stackoverflow.

Lire des livres

Lire des (bons) livres plutôt que des (mauvais) tutoriels. Cf Bibliographie

Communauté

Bonne nouvelle le Python est un écosystème informatique plutôt sain: culture libriste et passion de l’informatique dans la communauté python. N’hésitez pas à aller rencontrer d’autre développeurs.

Après cette formation

Le sujet est très vaste, le métier de développeur est long à intégrer. Il faut “passer plusieurs couches de peintures”. Nous allons parcourir pas mal de distance (en profondeur) et vous pourrez (devriez ?) creuser en largeur par la suite grâce aux références indiquées.

Mémo Syntaxe Python

Récapitulation des principales syntaxes Python

Demander et afficher des informations

Syntaxe Description
print("message") Affiche “message” dans la console
v = input("message") Demande une valeur et la stocke dans v

Calculs

Syntaxe Description
a + b Addition de a b
a - b Soustraction de a et b
a / b Division de a par b
a * b Multiplication de a par b
a % b Modulo (reste de division) de a par b
a ** b Exponentiation de a par b

Toutes ces opérations peuvent être appliquées directement sur une variable via la syntaxe du type a += b (additionner b à a et directement modifier la valeur de a avec le résultat).

Types de variable et conversion

Syntaxe Description
type(v) Renvoie le type de v
int(v) Converti v en entier
float(v) Converti v en float
str(v) Converti v en string

Chaînes de caractères

Syntaxe Description
chaine1 + chaine2 Concatène les chaînes de caractères chaine1 et chaine2
chaine[n:m] Retourne les caractères de chaine depuis la position n à m
chaine * n Retourne chaine concaténée n fois avec elle-meme
len(chaine) Retourne la longueur de chaine
chaine.replace(a, b) Renvoie chaine avec les occurences de a remplacées par b
chaine.split(c) Créé une liste à partir de chaine en la séparant par rapport au caractère c
chaine.strip() “Nettoie” chaine en supprimant les espaces et \n au début et à la fin
\n Représentation du caractère ‘nouvelle ligne’

Fonctions

def ma_fonction(toto, tutu=3):
    une_valeur = toto * 6 + tutu
    return une_valeur

Cette fonction :

  • a pour nom ma_fonction ;
  • a pour argument toto et tutu ;
  • tutu est un argument optionnel avec comme valeur par défaut l’entier 3 ;
  • une_valeur est une variable locale à la fonction ;
  • elle retourne une_valeur ;

Conditions

if condition:
    instruction1
    instruction2
elif autre_condition:
    instruction3
elif encore_une_autre_condition:
    instruction4
else:
    instruction5
    instruction6

Opérateurs de conditions

Syntaxe Description
a == b Egalité entre a et b
a != b Différence entre a et b
a > b a supérieur (strictement) à b
a >= b a supérieur ou égal à b
a < b a inférieur (strictement) à b
a <= b a inférieur ou égal à b
cond1 and cond2 cond1 et cond2
cond1 or cond2 cond1 ou cond2
not cond négation de la condition cond
a in b a est dans b (chaîne, liste, set..)

Inline ifs

parite = "pair" if n % 2 == 0 else "impair"

Exception, assertions

try/except permettent de tenter des instructions et d’attraper les exceptions qui peuvent survenir pour ensuite les gérer de manière spécifique :

try:
   instruction1
   instruction2
except FirstExceptionTime:
   instruction3
except Exception as e:
   print("an unknown exception happened ! :" + e.str)

Les assertions permettent d’expliciter et de vérifier des suppositions faites dans le code :

def une_fonction(n):
   assert isinstance(n, int) and is_prime(n), "Cette fonction fonctionne seulement pour des entiers premiers !"

Boucles

Syntaxe Description
for i in range(0, 10) Itère sur i de 0 à 9
for element in iterable Itère sur tous les elements de iterable (liste, set, dict, …)
for key, value in d.items() Itère sur toutes les clefs, valeurs du dictionnaire d
while condition Répète un jeu d’instruction tant que condition est vraie
break Quitte immédiatement une boucle
continue Passe immédiatement à l’itération suivante d’une boucle

Structures de données

Syntaxe Description
L = ["a", 2, 3.14 ] Liste (suite ordonnée d’éléments)
S = { "a", "b", 3 } Ensemble (éléments unique, désordonné)
D = { "a": 2, "b": 4 } Dictionnaire (ensemble de clé-valeurs, avec clés uniques)
T = (1,2,3) Tuple (suite d’élément non-mutables)
Syntaxe Description
L[i] i-eme element d’une liste ou d’une tuple
L[i:] Liste de tous les éléments à partir du i-eme
L[i] = e Remplace le i-eme element par e dans une liste
L.append(e) Ajoute e à la fin de la liste L
S.add(e) Ajoute e dans le set S
L.insert(i, e) Insère e à la position i dans la liste L
chaine.join(L) Produit une string à partir de L en intercallant la string chaine entre les elements

Fichiers

Ouvrir et lire un fichier :

# Créé un contexte dans lequel le fichier
# est ouvert en lecture en tant que 'f', 
# et met son contenu dans 'content'

with open("/un/fichier", "r") as f:  
    content = f.readlines()          
                                     

Ecrire dans un fichier :

# Créé un contexte dans lequel le fichier
# est ouvert en ré-écriture complète et
# écrit le contenu de 'content' dedans.

with open("/un/fichier", "w") as f:  
    f.write(content)                 
                                     

(Le mode 'a' (append) au lieu de 'w' permet d’ouvrir le fichier pour ajouter du contenu à la fin plutôt que de le ré-écrire)

Partie 1 - Notions de base

Cours 1

0. Setup de développement Python

Notre premier outil développement est bien sur l’interpréteur python lui même utilisé pour lancer un fichier de code.

Installation

  • Sur linux installer le paquet python3 (généralement déjà installé parce que linux utilise beaucoup python)
  • Sur Windows installer depuis python.org ou depuis un outil comme chocolatey
  • Sur MacOs déjà installé mais pour gérer un version plus à jours on peut le faire manuellement depuis python.org ou avec homebrew.

Python 2 vs Python 3

  • Python 2 existe depuis 2000
  • Python 3 existe depuis 2008
  • Fin de vie de Python 2 en 2020
  • … mais encore la version par défaut dans de nombreux système … (c.f. python --version)

Généralement il faut lancer python3 explicitement ! (et non python) pour utiliser python3

Différences principales

  • print "toto" ne fonctionnera pas en Python 3 (utiliser print("toto")
  • Nommage des paquets debian (python-* vs python3-*)
  • Gestion de l’encodage
  • range, xrange
  • Disponibilité des librairies ?

Il existe des outils comme 2to3 pour ~automatiser la transition.

Executer un script explicitement avec python

$ python3 hello.py

ou implicitement (shebang)

#!/usr/bin/env python3

print("Hello, world!")

puis on rend le fichier executable et on l’execute

$ chmod +x hello.py
$ ./hello.py

Ex.0 Hello world

  • Démarrer VS Code

  • Écrire et lancer le programme suivant :

print("Hello World!")
  • Créez un fichier hello.py directement dans la console (par exemple via nano hello.py) et mettez dedans :
#!/usr/bin/env python3
print("Hello, world!")
  • Executez ensuite ce script à l’aide de python3 hello.py ou ./hello.py dans un terminal

En interactif

$ python3
>>> print("Hello, world!")

ipython3 : alternative à la console python ‘classique’

$ sudo apt install ipython3
$ ipython3
In [1]: print("Hello, world!")

Principaux avantages:

  • Complétion des noms de variables et de modules avec TAB
  • Coloré pour la lisibilité
  • Plus explicite parfois
  • des commandes magiques comme %cd, %run script.py,

Inconvénients:

  • Moins standard
  • à installer en plus de l’interpréteur python.
pour quitter : exit

Les éditeurs de code

VSCode est un éditeur de code récent et très à la mode, pour de bonnes raisons:

  • Il est simple ou départ et fortement extensible: à l’installation seules les fonctionnalités de base sont disponibles
    • Éditeur de code avec coloration et raccourcis pratiques
    • Navigateur de fichier (pour manipuler une grande quantité de fichers et sous dossier sans sortir de l’éditeur)
    • Recherche et remplacement flexible avec des expressions régulières (très important pour trouver ce qu’on cherche et faire de refactoring)
    • Terminal intégrée (On a plein d’outils de développement à utiliser dans le terminal)
    • Une interface git assez simple très bien faite (git on s’y perd facilement, une bonne interface aide à s’y retrouver)

Indépendamment du logiciel choisi on trouve en général toutes ces fonctionnalités dans un éditeur de code.

Observons un peu tout ça avec une démo de VSCode et récapitulons l’importance des ces fonctions.

Installer des extensions pertinentes

Au sein de l’éditeur nous voulons coder en Python et également:

  • Pouvoir détecter les erreurs de syntaxe.
  • Pouvoir explorer le code python réparti dans plusieurs fichiers (sauter à la définition d’une fonction par exemple).
  • Complétion automatique des noms de symboles (ça peut être pénible parfois).
  • Pouvoir debugger le code python de façon agréable.
  • Pouvoir refactorer (changer le nom de variables ou fonctions partout automatiquement).

Installez l’extension Python (et affichez la documentation si vous êtes curieux) en allant dans la section Extensions (Icone de gauche avec 4 carrés dont un détaché)

Nous allons également utiliser git sérieusement donc nous allons installer une super extension git appelée Gitgraph pour pouvoir mieux explorer l’historique d’un dépôt git.

Enfin vous pouvez installer d’autres extensions pour personnaliser l’éditeur comme l’extension VIM si vous aimez habituellement utiliser cet éditeur.

Opensource et extensibilité : ne pas s’enfermer dans un environnement de travail

  • VSCode est développé par Microsoft et partiellement opensource (Le principal code est accessible mais pas tout)
  • VSCodium est la version opensource communautaire de VSCode mais certaines fonctions puissantes et pratiques sont seulement dans VSCode (les environement distant Docker et SSH par exemple)
  • Un fork récent et complètement opensource de VSCode qui peut fonctionner directement dans le navigateur (Cf. gitpod.io). Moins mature.

Ces trois logiciels sont très proches et vous pouvez coder vos extensions (compatibles avec les 3) pour étendre ces éditeur.

Il me semble important pour choisir un outil de se demander si on possède l’outil ou si l’outil nous possède (plus ou moins les deux en général). Pour pouvoir gérér la complexité du développement moderne on dépend de pas mal d’outils. Savoir choisir des outils ouverts et savoir utiliser également les outils en ligne commande (git, pylint, etc cf. suite du cours) est très important pour ne pas s’enfermer dans un environnement limitant et possessif.

1. Les variables

1.1. Exemple

message = "Je connais la réponse à l'univers, la vie et le reste"
reponse = 6 * 7

print(message)
print(reponse)

sorcery

1.2. Principe

  • Les variables sont des abstractions de la mémoire
  • Une étiquette collée apposée sur une partie de la mémoire : nom pointe vers un contenu
  • Différent du concept mathématique

1.3. Déclaration, utilisation

  • En python : déclaration implicite
  • Ambiguité : en fonction du contexte, x désigne soit le contenant, soit le contenu…
x = 42     # déclare (implicitement) une variable et assigne une valeur
x = 3.14   # ré-assigne la variable avec une autre valeur
y = x + 2  # déclare une autre variable y, à partir du contenu de x
print(y)   # affichage du contenu de y

Nommage

  • Caractères autorisés : caractères alphanumériques (a-zA-Z0-9) et _.
  • Les noms sont sensibles à la casse : toto n’est pas la même chose que Toto!
  • (Sans commencer par un chiffre)

Comparaison de différentes instructions

Faire un calcul sans l’afficher ni le stocker nul part:

6*7

Faire un calcul et l’afficher dans la console:

print(6*7)

Faire un calcul et stocker le résultat dans une variable r pour le réutiliser plus tard

r = 6*7

Opérations mathématiques

2 + 3   # Addition
2 - 3   # Soustraction
2 * 3   # Multiplication
2 / 3   # Division
2 % 3   # Modulo
2 ** 3  # Exponentiation

Calcul avec réassignation

x += 3   # Équivalent à x = x + 3
x -= 3   # Équivalent à x = x - 3
x *= 3   # Équivalent à x = x * 3
x /= 3   # Équivalent à x = x / 3
x %= 3   # Équivalent à x = x % 3
x **= 3  # Équivalent à x = x ** 3

Ex.1.1 Calculs dans l’interpréteur

  • À l’aide de python, calculer le résultat des opérations suivantes :
    • 567×72
    • 33⁴
    • 98.2/6
    • ((7×9)⁴)/6
    • vrai et non (faux ou non vrai)

Types

42            # Entier / integer               / int
3.1415        # Réel                           / float
"Marius"        # Chaîne de caractère (string)   / str
True / False  # Booléen                        / bool
None          # ... "rien" / aucun (similar à `null` dans d'autres langages)

Connaître le type d’une variable : type(variable)

Conversion de type

int("3")      -> 3
str(3)        -> "3"
float(3)      -> 3.0
int(3.14)     -> 3
str(3.14)     -> "3.14"
float("3.14") -> 3.14
int(True)     -> 1
int("trois")  -> Erreur / Exception

Interactivité basique

Dans un terminal il est possible de demander une information à l’utilisateur avec `input(“message”)

reponse = input("Combien font 6 fois 7 ?")

N.B. : ce que renvoie input() est une chaîne de caractère !

Ex.1.2 Interactivité

  • Demander l’année de naissance de l’utilisateur, puis calculer et afficher l’âge qu’il aura dans deux ans (approximativement, sans tenir compte du jour et mois de naissance…).

2. Chaînes de caractères

Syntaxe des chaînes

  • Entre simple quote (') ou double quotes ("). Par exemple: "hello"
  • print("hello") affiche le texte Hello
  • print(hello) affiche le contenu d’une variable qui s’apellerait Hello

Longueur

m = "Hello world"
len(m)        # -> 11

Extraction

m[:5]    # -> 'Hello'
m[6:8]   # -> 'wo'
m[-3:]   # -> 'rld'

Multiplication

"a" * 6    # -> "aaaaaa"

Concatenation

"Cette phrase" + " est en deux morceaux."
name = "Marius"
age = 28
"Je m'appelle " + name + " et j'ai " + str(age) + " ans"

Construction à partir de données, avec %s

"Je m'appelle %s et j'ai %s ans" % ("Marius", 28)

Construction à partir de données, avec format

"Je m'appelle {name} et j'ai {age} ans".format(name=name, age=age)

Substitution

"Hello world".replace("Hello", "Goodbye")   # -> "Goodbye world"

Chaînes sur plusieurs lignes

  • \n est une syntaxe spéciale faisant référence au caractère “nouvelle ligne”
"Hello\nworld"     # -> Hello <nouvelle ligne> world

Interactivité basique avec input

En terminal, il est possible de demander une information à l’utilisateur avec input("message")

reponse = input("Combien font 6 fois 7 ?")

N.B. : ce que renvoie input() est une chaîne de caractère !

Et bien d’autres choses !

c.f. documentation, e.g https://devdocs.io/python~3.7/library/stdtypes#str

Ex.2 Chaînes de caractères

2.1 Demander un mot à l’utilisateur. Afficher la longueur du mot avec une message tel que "Ce mot fait X caractères !"

2.2 Afficher le mot encadré avec des ####. Par exemple:

##########
# Python #
##########

3. Les fonctions

Principe

Donner un nom à un ensemble d’instructions pour créer de la modularité et de la sémantique

def ma_fonction(arg1, arg2):
    instruction1
    instruction2
    ...
    return resultat

On peut ensuite utiliser la fonction avec les arguments souhaitées et récupérer le resultat :

mon_resultat = ma_fonction("pikachu", "bulbizarre")
autre_resultat = ma_fonction("salameche", "roucoups")
Calculs mathématiques
sqrt(2)        -> 1.41421 (environ)
cos(3.1415)    -> -1 (environ)
Générer ou aller chercher des données
nom_du_departement(67)        -> "Bas-rhin"
temperature_actuelle("Lyon")  -> Va chercher une info sur internet et renvoie 12.5
Convertir, formatter, filtrer, trier des données …
int("3.14")                     -> 3
normalize_url("toto.com/pwet/") -> https://toto.com/pwet
sorted(liste_de_prenoms)     -> renvoie la liste triée alphabétiquement
**Afficher / demander des données **
print("un message")
input("donne moi un chiffre entre 1 et 10 ?")

Exemples concrets

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)      # -> A1 vaut 15 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !


def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A3 = aire_disque(6)           # -> A3 vaut (environ) 113 !

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)      # -> A1 vaut 7.5 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !


def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A3 = aire_disque(6)           # -> A3 vaut (environ) 113


def volume_cylindre(rayon, hauteur):
    return hauteur * aire_disque(rayon)

V1 = volume_cylindre(6, 4)   # -> A4 vaut (environ) 452

Écrire une fonction

Éléments de syntaxe

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree
  • def, :
  • des instructions indentées !!
  • des arguments (ou pas!)
  • return (ou pas)

Les arguments

def aire_disque(rayon):
    # [ ... ]
  • Une fonction est un traitement générique. On ne connait pas à l’avance la valeur précise qu’aura un argument, et généralement on appelle la fonction pleins de fois avec des arguments différents…
  • En définissant la fonction, on travaille donc avec un argument “abstrait” nommé rayon
  • Le nom rayon en tant qu’argument de la fonction n’a de sens qu’a l’intérieur de cette fonction !
  • En utilisant la fonction, on fourni la valeur pour rayon, par exemple: aire_disque(6).

Les variables locales

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    # [ ... ]
  • Les variables créées dans la fonction sont locales: elles n’ont de sens qu’a l’intérieur de la fonction
  • Ceci dit, cela ne m’empêche pas d’avoir des variables aussi nommées rayon ou rayon_carree dans une autre fonction ou dans la portée globale (mais ce ne sont pas les mêmes entités)

Le return

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree
  • return permet de récupérer le résultat de la fonction
  • C’est ce qui donne du sens à A = aire_disque(6) (il y a effectivement un résultat à mettre dans A)
  • Si une fonction n’a pas de return, elle renvoie None
  • return quitte immédiatement la fonction

Erreur classique:

Utiliser print au lieu de return

Ce programme n’affiche rien

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A = aire_disque(6)      # A vaut bien quelque chose
                        # mais nous ne demandons pas de l'afficher ...

Solution naive : remplacer le return par un print

def aire_disque(rayon):
    rayon_carree = rayon ** 2
    print(3.1415 * rayon_carree)    # Affiche le résultat dans la console

A = aire_disque(6)   # Mais maintenant A vaut None
                     # car la fonction n'a pas utilisé `return`
“Bonne” solution
def aire_disque(rayon):
    rayon_carree = rayon ** 2
    return 3.1415 * rayon_carree

A = aire_disque(6)   # Stocker le résultat dans A
print(A)             # Demander d'afficher A dans la console

Ceci dit, il peut être tout à fait légitime de mettre des print dans une fonction, par exemple pour la débugger…!

Appel de fonction avec arguments explicites

def aire_triangle(base, hauteur):
    return base * hauteur / 2

A1 = aire_triangle(3, 5)
A2 = aire_triangle(4, hauteur=8)
A3 = aire_triangle(hauteur=6, base=2)
A4 = aire_triangle(hauteur=3, 2)    # < Pas possible !

N.B. : cette écriture est aussi plus explicite / lisible / sémantique:

aire_triangle(base=3, hauteur=5)

que juste

aire_triangle(3, 5)

On peut se retrouver dans des situations comme:

base = 3
hauteur = 5

A1 = aire_triangle(base=base, hauteur=hauteur)

Dans l’appel de la fonction :

  • le premier base est le nom de l’argument de la fonction aire_triangle,
  • le deuxième base corresponds au contenu de la variable nommée base.

Arguments optionnels

Les arguments peuvent être rendu optionnels si ils ont une valeur par défaut :

def distance(dx, dy=0, dz=0):
    [...]

Dans ce cas, tous ces appels sont valides :

distance(5)
distance(2, 4)
distance(5, 8, 2)
distance(9, dy=5)
distance(0, dz=4)
distance(1, dy=1, dz=9)
distance(2, dz=4, dy=7)

Exemple réaliste

subprocess.Popen(args,
                 bufsize=0,
                 executable=None,
                 stdin=None,
                 stdout=None,
                 stderr=None,
                 preexec_fn=None,
                 close_fds=False,
                 shell=False,
                 cwd=None,
                 env=None,
                 universal_newlines=False,
                 startupinfo=None,
                 creationflags=0)

c.f. https://docs.python.org/2/library/subprocess.html#subprocess.Popen

Ex.3 Fonctions

3.1 Écrire une fonction annee_naissance qui prends en argument un age et retourne l’année de naissance (+/- 1) sachant que nous sommes en 2019. Par exemple, annee_naissance(29) retounera l’entier 1990.

3.2

  • Ecrire une fonction centrer prend en argument une chaîne de caractère, et retourne une nouvelle chaîne centrée sur 40 caractères. Par exemple print(centrer("Python")) affichera :
|                Python                |
  • Ajouter un argument optionnel pour gérer la largeur au lieu du 40 “codé en dur”. Par exemple print(centrer("Python", 20)) affichera :
|      Python      |
  • Créer une fonction encadrer qui utilise la fonction centrer pour produire un texte centré et encadré avec des ####. Par exemple, print(encadrer("Python", 20)) affichera :
####################
|      Python      |
####################

4. Conditions et branchements conditionnels

Pour pouvoir écrire des applications il faut des techniques permettant de contrôler le déroulement du programme dans différentes directions, en fonction des circonstances. Pour cela, nous devons disposer d’instructions capables de tester une certaine condition et modifier le comportement du programme en conséquence.

La principale instruction conditionnelle est, en python comme dans les autres langages impératifs, le if (Si condition alors …) assorti généralement du else (Sinon faire …) et en python de la contraction elif de else if (Sinon, Si condition alors …)e

Syntaxe générale

if condition:
    instruction1
    instruction2
elif (autre condition):
    instruction3
elif (encore autre condition):
    instruction4
else:
    instruction5
    instruction6

Attention à l’indentation !

Tout n’est pas nécessaire, par exemple on peut simplement mettre un if :

if condition:
    instruction1
    instruction2

Exemple

a = 0
if a > 0 :
    print("a est positif")
elif a < 0 :
    print("a est négatif")
else:
    print("a est nul")

Lien avec les booléens

Les conditions comme a > 0 sont en fait transformées en booléen lorsque la ligne est interprétée.

On aurait pu écrire :

a_est_positif = (a > 0)

if a_est_positif:
    [...]
else:
    [...]

Écrire des conditions

angle == pi      # Égalité
angle != pi      # Différence
angle > pi       # Supérieur
angle >= pi      # Supérieur ou égal
angle < pi       # Inférieur
angle <= pi      # Inférieur ou égal

Combiner des conditions

x = 2

print("x > 0:", x > 0) # vrai
print("x > 0 and x == 2:", x > 0 and x == 2) # vrai et vrai donne vrai
print("x > 0 and x == 1:", x > 0 and x == 2) # vrai et faux donne faux
print("x > 0 or x == 1:", x > 0 or x == 1) # vrai ou faux donne vrai
print("not x == 1:", not x == 1) # non faux donne vrai
print("x > 0 or not x == 1:", x > 0 or not x == 1) # vrai ou (non faux) donne vrai ou vrai donne vrai

Conditions “avancées”

Chercher des choses dans des chaînes de caractères

"Jack" in nom           # 'nom' contient 'Jack' ?
nom.startswith("Jack")  # 'nom' commence par 'Jack' ?
nom.endswith("ack")     # 'nom' fini par 'row' ?

Remarque: l’opérateur in est très utile et générale en Python: il sert à vérifier qu’un élément existe dans une collection. Par exemple si l’entier 2 est présent dans une liste d’entier ou comme ici si un mot est présent dans une chaine de caractère.

‘Inline’ ifs

On peut rassembler un if else sur une ligne comme suit:

parite = "pair" if n % 2 == 0 else "impair"

Tester si une variable a une valeur de façon “pythonique”.

En python pour tester si une variable contient une valeur vide ou pas de valeur (c-à-d valeur None) on aime bien, par convention “pythonique”, écrire simplement if variable: :

reste_division = a % 2

if reste_division:
    print("a est pair parce que le reste de sa division par 2 est nul")
else:
    print("a est impair")

Pareil pour tester si unt chaîne de caractère est vide ou nulle:

texte = input()

if texte:
    print("vous avez écrit: ", texte)
else:
    print("pas de texte")
    print("texte is None :", texte is None)
    print("texte == \"\" (chaine vide) :", texte == "")

Remarque: dans notre dernier cas il n’est pas forcément important de savoir si texte est None ou une chaîne vide mais plutôt de savoir si on a effectivement une valeur “significative” à afficher. C’est souvent le cas et c’est pour cela qu’on privilégie if variable pour simplifier la lecture du code.

Vraisemblance (truthiness) d’un valeur

L’usage de if variable: comme précédemment est basé sur la truthiness ou vraisemblance de la variable. On dit que a est vraisemblable si la conversion de a en booléen donne True : bool(3) donne True on dit que 3 est truthy, bool(None) donne False donc None est falsy. TODO Nous verrons dans la partie sur le Python Data Model que cela implique des choses pour nos classes de programmation orientée objet en python (en Résumé on veut que if monObjet: soit capable de tester si l’objet est initialisé et utilisable) Autrement dit en python on aime utiliser la vraisemblance implicite des variables pour tester si leur valeur est significative/initialisée ou non.

Ex.4 Conditions

4.1 Reprendre la fonction annee_naissance et afficher un message d’erreur et sortir immédiatement de la fonction si l’argument fourni n’est pas un nombre entre 0 et 130. Valider le comportement en appelant votre fonction avec comme argument -12, 158, None ou "toto".

  • Inspecter l’execution du code pas à pas à l’aide du debugger VSCode.

4.2 Reprendre la fonction centrer de l’exercice 3.1 et gérer le cas où la largueur demandée est -1 : dans ce cas, ne pas centrer. Par exemple, print(encadrer("Python", -1)) affichera :

##########
# Python #
##########

5. Les boucles

Répéter des opération est le coeur de la puissance de calcul des ordinateur. On peut pour cela utiliser des boucles ou des appels récusifs de fonctions. Les deux boucles python sont while et for.

La boucle while

while <condition>: veut dire “tant que la condition est vraie répéter …”. C’est une boucle simple qui teste à chaque tour (avec une sorte de if) si on doit continuer de boucler.

Exemple:

a = 0
while (a < 10) # On répète les deux instructions de la boucle tant que a est inférieur à 7
    a = a + 1 # A chaque tour on ajoute 1 à la valeur de a
    print(a)

La boucle for et les listes

La boucle for en Python est plus puissante et beaucoup plus utilisée que la boucle while car elle “s’adapte aux données” et aux objets du programme grâce à la notion d’itérateur que nous détaillerons plus loin. (De ce point de vue, la boucle for python est très différente de celle du C/C++ par exemple)

On peut traduire la boucle Python for element in collection: en français par “Pour chaque élément de ma collection répéter …”. Nous avons donc besoin d’une “collection” (en fait un iterateur) pour l’utiliser. Classiquement on peut utiliser une liste python pour cela:

ma_liste = [7, 2, -5, 4]

for entier in ma_liste:
    print(entier)

Pour générer rapidement une liste d’entiers et ainsi faire un nombre défini de tours de boucle on utilise classiquement la fonction range()

print(range(10))

for entier in range(10):
    print(entier) # Afficher les 10 nombres de 0 à 9
for entier in range(1, 11):
    print(entier) # Afficher les 10 nombres de 1 à 10
for entier in range(2, 11, 2):
    print(entier) # Afficher les 5 nombres pairs de 2 à 10 (le dernier paramètre indique d'avancer de 2 en 2)

continue et break

continue permet de passer immédiatement à l’itération suivante

break permet de sortir immédiatement de la boucle

for i in range(0,10):
    if i % 2 == 0:
        continue

    print("En ce moment, i vaut " + str(i))

-> Affiche le message seulement pour les nombres impairs

for i in range(0,10):
    if i == 7:
        break

    print("En ce moment, i vaut " + str(i))

-> Affiche le message pour 0 à 6

Ex.5 Boucles

5.1.1 : Écrire une fonction qui, pour un nombre donné, renvoie la table de multiplication. Dans un premier temps, on pourra se contenter d’afficher les résultats. Par exemple print(table_du_7()) affichera:

7
14
21
...
70

puis ensuite on peut améliorer la présentation pour obtenir le résultat :

Table du 7
----------
 1 x 7 = 7
 2 x 7 = 14
 [..]
 10 x 7 = 70

5.1.2 : Cette fois, passer le nombre en argument. La fonction devient par exemple table_multiplication(7)

5.1.3 : En appelant cette fonction plusieurs fois, afficher les tables de multiplication pour tous les nombres entre 1 et 10.

5.1.4 : Protéger l’accès à toute cette connaissance précieuse en demandant, au début du programme, un “mot de passe” jusqu’à ce que le bon mot de passe soit donné.

5.2 : (Optionnel) Écrire une fonction qui permet de déterminer si un nombre est premier. Par exemple is_prime(3) renverra True, et is_prime(10) renverra False.

(Optionnel) 5.3.1 : Jeu des allumettes

Le jeu des allumettes est un jeu pour deux joueurs, où n allumettes sont disposées, et chaque joueur peut prendre à tour de rôle 1, 2 ou 3 allumettes. Le perdant est celui qui se retrouve obligé de prendre la dernière allumette.

  • Écrire une fonction afficher_allumettes capable d’afficher un nombre donné d’allumettes (donné en argument), par exemple avec le caractère |
  • Écrire une fonction choisir_nombre qui demande à l’utilisateur combien d’allumette il veut prendre. Cette fonction vérifiera que le choix est valide (en entier qui est soit 1, 2 ou 3).
  • Commencer la construction d’une fonction partie_allumettes qui pour le moment, se contente de :
    • Initialiser le nombre d’allumette sur la table
    • Afficher des allumettes avec afficher_allumettes
    • Demander à l’utilisateur combien il veut prendre d’allumettes avec choisir_nombre
    • Propager ce choix sur le nombre d’allumette actuellement sur la table
    • Afficher le nouvel état avec afficher_allumettes

5.3.2 : (Optionnel) Modifier partie_allumettes pour gérer deux joueurs (1 et 2) et les faire jouer à tour de rôle jusqu’à ce qu’une condition de victoire soit détectée (il reste moins d’une allumette…).

5.3.3 : (Optionnel) Intelligence artificielle

Reprendre le jeu précédent et le modifier pour introduire une “intelligence” artificielle qui soit capable de jouer en tant que 2ème joueur. (Par exemple, une stratégie très simple consiste à prendre une allumette quoiqu’il arrive)

5.3.4 : (Optionnel) Installer pylint3 avec:

pip3 install pylint3

Analyser son code avec pylint3

6. Principes de développement - Partie 1

Écrire un programme … pour qui ? pour quoi ?

Le fait qu’un programme marche n’est pas suffisant voire parfois “secondaire” !

  • … Mieux vaut un programme cassé mais lisible (donc débuggable)
  • … qu’un programme qui marche mais incompréhensible (donc fragile et/ou qu’on ne saura pas faire évoluer)
  • … et donc qui va surtout faire perdre du temps aux futurs développeurs

Autrement dit : la lisibilité pour vous et vos collègues a énormément d’importance pour la maintenabilité et l’évolution d’un projet

Posture de développeur et bonnes pratiques

  • Lorsqu’on écrit du code, la partie “tester” et “debugger” fait partie du job.

On écrit pas un programme qui marche au premier essai

  • Il faut tester et débugger au fur et à mesure, pas tout d’un seul coup !

Le debugging interactif : pdb, ipdb, VSCode

  • PDB = Python DeBugger

  • Permet (entre autre) de définir des “break points” pour rentrer en interactif

    • import ipdb; ipdb.set_trace()
    • en 3.7 : breakpoint() Mais fait appel à pdb et non ipdb ?
  • Une fois en interactif, on peut inspecter les variables, tester des choses, …

  • On dispose aussi de commandes spéciales pour executer le code pas-à-pas

  • Significativement plus efficace que de rajouter des print() un peu partout !

Commandes pdb et ipdb

  • l(ist) : affiche les lignes de code autour de code (ou continue le listing precedent)

  • c(ontinue) : continuer l’execution normalement (jusqu’au prochain breakpoint)

  • s(tep into) : investiguer plus en détail la ligne en cours, possiblement en descendant dans les appels de fonction

  • n(ext) : passer directement à la ligne suivante

  • w(here) : print the stack trace, c.a.d. les différents sous-appels de fonction dans lesquels on se trouve

  • u(p) : remonte d’un cran dans les appels de la stacktrace

  • d(own) : redescend d’un cran dans les appels de la stacktrace

  • b(reak) : fixe un point d’arrêt (breakpoint) à la ligne donnée.

  • tbreak : fixe un point d’arrêt temporaire qui sera retiré au premier passage.

  • pp <variable> : pretty-print d’une variable (par ex. une liste, un dict, ..)

Debug VSCode

  • Dans VSCode on peut fixer des breakpoints (points rouges) directement dans le code en cliquant sur la colonne de gauche de l’éditeur.
  • Il faut ensuite aller dans l’onglet debug et sélectionner une configuration de debug ou en créer une plus précise (https://code.visualstudio.com/docs/python/python-tutorial)
  • Ensuite on lance le programme en mode debug et au moment de l’arrêt il est possible d’explorer les valeurs de toutes les variables du programme (Démo)

Bonnes pratiques pour la lisibilité, maintenabilité

  • Keep It Simple

  • Sémantique : utiliser des noms de variables et de fonctions qui ont du sens

  • Architecture : découper son programme en fonction qui chacune résolvent un sous-problème précis

  • Robustesse : garder ses fonctions autant que possibles indépendantes, limiter les effets de bords

    • lorsque j’arose mes plantes, ça ne change pas la température du four
  • Lorsque mon programme évolue, je prends le temps de le refactoriser si nécessaire

    • si je répète plusieurs fois les mémes opérations, il peut être intéressant d’introduire une nouvelle fonction
    • si le contenu d’une variable ou d’une fonction change, peut-être qu’il faut modifier son nom
    • si je fais pleins de petites opérations bizarre, peut-être qu’il faut créer une fonction

Quelques programmes réels utilisant Python

Dropbox

Atom

Eve online

Matplotlib

Blender

OpenERP / Odoo

Tartiflette

Ex.6 Performances et debugging : plusieurs implémentations de la suite de fibonacci

La célèbre suite de Fibonacci, liée au nombre d’or, est une suite d’entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Mais elle est également un exercice classique d’algorithmique.

  • Écrire une fonction fibonacci_rec_naive(n) qui calcule de façon récursive la suite de fibonacci.

  • Créez une autre fonction fibonacci_iter(n) qui calcule de façon iterative la suite de fibonacci.

  • Calculez le 40e terme de la suite avec chacune des implémentation précédente.

  • Debuggez les deux implémentations. Que se passe-t-il ?

  • A l’aide de la librairie timeit et de sa fonction timer (from timeit import default_timer as timer) qui renvoie le temps processeur courant, mesurez le temps d’exécution des deux fonctions.

  • Écrire une fonction fibonacci_rec_liste(n) qui calcule récursivement la suite de fibonacci en utilisant une liste comme mémoire pour ne pas recalculer les terme déjà calculés.

  • Bonus 1: Utilisons un décorateur de “caching” de fonction (from functools import lru_cache as cache) sur fibonacci_rec_naive(n) pour l’optimiser sans changer le code.

  • Bonus 2: Écrivons une implémentation pythonique de fibonacci utilisant un générateur

Corrections 1

Exercice 1.1

result_1 = 567 * 72
result_2 = 33**4
result_3 = 98.2 / 6
result_4 = (7 * 9)**4 / 6

print(result_1)
print(result_2)
print(result_3)
print(result_4)

Exercice 1.2

annee = int(input('Quelle est votre année de naissance ?\n'))
age = 2021 - annee + 2
print("Dans deux ans vous aurez {} ans.".format(age))

2.1 Compter les lettres

mot = input("Donnez moi un mot.\n")
print("Ce mot fait {} caractères (espaces inclus).".format(len(mot)))
print("#"*len(mot)+2+"\n"+)

2.2 Encadrer le mot avec

mot_encadre = '#### ' + mot + ' ####'
print("mot encadré: {}".format(mot_encadre))

Exercice 3: Fonctions

3.1

def annee_naissance(age):
  return 2021 - age
print(annee_naissance(32))

3.2

def centrer(mot, largeur=80):

	nb_espaces = largeur - len(mot) - 2
    nb_espaces_gauche = nb_espaces // 2     # division entière:  25 // 2 -> 12
    nb_espaces_droite = nb_espaces - nb_espaces_gauche

    resultat = "|" + nb_espaces_gauche * " " + mot + nb_espaces_droite * " " + "|"

    return resultat


def encadrer(mot, largeur=80, caractere='@'):
	ligne1 = caractere * largeur
    ligne2 = centrer(mot, largeur)

    return "{}\n{}\n{}".format(ligne1, ligne2, ligne1)


print(centrer("Pikachu"))
print(len(centrer("Pikachu")) # 80
print(centrer("Pikachu", 40))

print(encadrer("Pikachu"))
print(encadrer("Pikachu", 37))
print(encadrer("Pikachu", 71, "#"))

Exercice 4: Conditions

4.1

def annee_naissance(age):
  if isinstance(age,int) and 0 < age < 130:
    return 2021-age

4.2

def centrer(mot, largeur=80):
	nb_espaces = largeur - len(mot) - 2
    nb_espaces_gauche = nb_espaces // 2     # division entière:  25 // 2 -> 12
    nb_espaces_droite = nb_espaces - nb_espaces_gauche

    resultat = "|" + nb_espaces_gauche * " " + mot + nb_espaces_droite * " " + "|"

    return resultat


def encadrer(mot, largeur=80, caractere='@'):
	if largeur == -1:
    	largeur = len(mot) + 4

    if caractere == '':
    	return centrer(mot, largeur)

    longueur_max = largeur - 4
    if len(mot) > longueur_max:
    	mot = mot[:longueur_max]

 	ligne1 = caractere * largeur
    ligne2 = centrer(mot, largeur).replace("|", caractere)

    return "{}\n{}\n{}".format(ligne1, ligne2, ligne1)


print(encadrer("Pikachu", -1))
print(encadrer("Pikachu", 34, ''))
print(encadrer("Pikachu", 8, '@'))

Exercice 5

5.1.1

def table_du_7():
  print("Table du 7")
  print("----------")
  for i in range(1,11):
    print("7 x {} = {}".format(i,7*i))

5.1.2

def table_multiplication(nombre):
  print("Table du {}".format(nombre))
  print("----------")
  for i in range(1,11):
    print("{} x {} = {}".format(nombre,i,nombre*i))

5.1.3

for i in range(1,11):
  table_multiplication(i)

5.1.4

mot_de_passe=input("Mot de passe?")
while not mot_de_passe=="123soleil":
        print("Accès non autorisé")
        mot_de_passe=input("Mot de passe?")
for i in range(1,11):
  table_multiplication(i)

5.2

def isprime(nombre):
  for i in range(nombre-1,1,-1):
    if nombre%i==0:
      return False
  return True

5.3

def afficher_allumettes(nombre_allumettes):
    for i in range(nombre_allumettes):
        print("|",end='')
    print("")

def choisir_nombre():
    correct=False
    while not correct:
        choix=int(input("Combien d'allumettes prend-tu?"))
        if choix in [1,2,3]:
            correct=True
    return choix

def jeu(allumettes):
    joueur=1
    while allumettes > 1:
        afficher_allumettes(allumettes)
        print("Joueur {}:".format(joueur))
        choix=choisir_nombre()
        while allumettes-choix <= 0:
            print("Choose again")
            print("Joueur {}:".format(joueur))
            choix=choisir_nombre()
        if allumettes-choix== 1:
            print("Joueur {} gagne".format(joueur))
            allumettes-=choix
            afficher_allumettes(allumettes)
        else:
            allumettes-=choix
        joueur=3-joueur

def jeu_avec_ia(allumettes):
    joueur=1
    while allumettes > 1:
        afficher_allumettes(allumettes)
        if joueur==1:
            print("Joueur {}:".format(joueur))
            choix=choisir_nombre()
            while allumettes-choix <= 0:
                print("Choose again")
                print("Joueur {}:".format(joueur))
                choix=choisir_nombre()
            if allumettes-choix== 1:
                print("Joueur {} gagne".format(joueur))
                allumettes-=choix
                afficher_allumettes(allumettes)
            else:
                allumettes-=choix
        if joueur==2:
            if allumettes== 2:
                print("IA gagne")
                afficher_allumettes(allumettes-1)
                return
            else:
                print("IA prend une allumette")
                allumettes-=1
        joueur=3-joueur
jeu(10)
jeu_avec_ia(10)

Exercice 6

from timeit import default_timer as timer
from functools import lru_cache as cache

def fib_rec_naive(n):
    """
    fib_rec_naive calcule le Ne terme de la suite de fibonacci
    En utilisant une approche récursive naive de complexité exponentielle
    """
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib_rec_naive(n-1) + fib_rec_naive(n-2)

@cache()
def fib_rec_naive_cache(n):
    """
    fib_rec_naive calcule le Ne terme de la suite de fibonacci
    En utilisant une approche récursive naive, mais en ajoutant
    un décorateur de memoïzation qui stocke l'état de la pile d'éxecution entre les appels
    """
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib_rec_naive_cache(n-1) + fib_rec_naive_cache(n-2)

liste_termes_calculés = [0,1]
def fib_rec_liste(n):
    """
    fib_rec_liste calcule le Ne terme de la suite de fibonacci
    En utilisant une approche récursive correcte de complexité linéaire
    en utilisant une mémoire sous forme de liste
    """
    if n < len(liste_termes_calculés):
        return liste_termes_calculés[n]
    else:
        liste_termes_calculés.append(fib_rec_liste(n-1) + fib_rec_liste(n-2))
        return liste_termes_calculés[n]

def fib_iter(n):
    """
    fib_iter calcule le Ne terme de la suite de fibonacci
    En utilisant une approche itérative de complexité linéaire
    """
    ancien_terme, nouveau_terme = 0, 1
    if n == 0:
        return 0

    for i in range(n-1):
        ancien_terme, nouveau_terme = nouveau_terme, ancien_terme + nouveau_terme

    return nouveau_terme


if __name__ == "__main__":

    # Temps avec 35 termes

    start = timer()
    fib_rec_naive(35)
    stop = timer()
    print( "fib_rec_naive(35) execution time: ", stop - start )

    start = timer()
    fib_rec_naive_cache(35)
    stop = timer()
    print( "fib_rec_naive_cache(35) execution time: ", stop - start )

    start = timer()
    fib_rec_liste(35)
    stop = timer()
    print( "fib_rec_list(35) execution time: ", stop - start )

    start = timer()
    fib_iter(35)
    stop = timer()
    print( "fib_iter(35) execution time: ", stop - start )

    # Temps avec 38 termes

    start = timer()
    fib_rec_naive(38)
    stop = timer()
    print( "fib_rec_naive(38) execution time: ", stop - start )

    start = timer()
    fib_rec_naive_cache(38)
    stop = timer()
    print( "fib_rec_naive_cache(38) execution time: ", stop - start )

    start = timer()
    fib_rec_liste(38)
    stop = timer()
    print( "fib_rec_list(38) execution time: ", stop - start )

    start = timer()
    fib_iter(38)
    stop = timer()
    print( "fib_iter(38) execution time: ", stop - start )

Bonus 2


def fibonacci_generator():
    a, b = 0, 1
    yield a
    yield b

    while True:
        a, b = (b, a+b)
        yield b

for n in fibonacci_generator():
    if n > 500:
        break
    print(n)

Exos 1

1. Calculs dans l’interpréteur

  • À l’aide de python, calculer le résultat des opérations suivantes :
    • 567×72
    • 33⁴
    • 98.2/6
    • ((7×9)⁴)/6
    • vrai et non (faux ou non vrai)

2. Interactivité

  • Demander l’année de naissance de l’utilisateur, puis calculer et afficher l’âge qu’il aura dans deux ans (approximativement, sans tenir compte du jour et mois de naissance…).

2. Chaînes de caractères

  • Demander un mot à l’utilisateur. Afficher la longueur du mot avec une message tel que "Ce mot fait X caractères !"

  • Afficher le mot encadré avec des ####. Par exemple:

##########
# Python #
##########

3. Fonctions

  • Ecrire une fonction centrer prend en argument une chaîne de caractère, et retourne une nouvelle chaîne centrée sur 40 caractères. Par exemple print(centrer("Python")) affichera :
|                Python                |
  • Ajouter un argument optionnel pour gérer la largeur au lieu du 40 “codé en dur”. Par exemple print(centrer("Python", 20)) affichera :
|      Python      |
  • Créer une fonction encadrer qui utilise la fonction centrer pour produire un texte centré et encadré avec des ####. Par exemple, print(encadrer("Python", 20)) affichera :
####################
|      Python      |
####################

4. Conditions

  • Reprendre la fonction annee_naissance et afficher un message d’erreur et sortir immédiatement de la fonction si l’argument fourni n’est pas un nombre entre 0 et 130. Valider le comportement en appelant votre fonction avec comme argument -12, 158, None ou "toto".

  • Inspecter l’execution du code pas à pas à l’aide du debugger VSCode.

  • Reprendre la fonction centrer de l’exercice 4.1 et gérer le cas où la largueur demandée est -1 : dans ce cas, ne pas centrer. Par exemple, print(encadrer("Python", -1)) affichera :

##########
# Python #
##########

5. Boucles

def afficher_allumettes(nombre_allumettes):
    for i in range(nombre_allumettes):
        print("|",end='')
    print("")

def choisir_nombre():
    correct=False
    while not correct:
        choix=int(input("Combien d'allumettes?"))
        if choix in [1,2,3]:
            correct=True
    return choix

def jeu(allumettes):
    while allumettes > 1:
        afficher_allumettes(allumettes)
        choix=choisir_nombre()
        if allumettes-choix <= 0:
            print("Choose again")
        elif allumettes-choix== 1:
            print("you loose")
            allumettes-=choix
            afficher_allumettes(allumettes)
        else:
            allumettes-=choix

jeu(10)

6. Performances et debugging : plusieurs implémentations de la suite de fibonacci

La célèbre suite de Fibonacci, liée au nombre d’or, est une suite d’entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Mais elle est également un exercice classique d’algorithmique.

  • Écrire une fonction fibonacci_rec_naive(n) qui calcule de façon récursive la suite de fibonacci.

  • Créez une autre fonction fibonacci_iter(n) qui calcule de façon iterative la suite de fibonacci.

  • Calculez le 40e terme de la suite avec chacune des implémentation précédente.

  • Debuggez les deux implémentations. Que se passe-t-il ?

  • A l’aide de la librairie timeit et de sa fonction timer (from timeit import default_timer as timer) qui renvoie le temps processeur courant, mesurez le temps d’exécution des deux fonctions.

  • Écrire une fonction fibonacci_rec_liste(n) qui calcule récursivement la suite de fibonacci en utilisant une liste comme mémoire pour ne pas recalculer les terme déjà calculés.

  • Bonus 1: Utilisons un décorateur de “caching” de fonction (from functools import lru_cache as cache) sur fibonacci_rec_naive(n) pour l’optimiser sans changer le code.

  • Bonus 2: Écrivons une implémentation pythonique de fibonacci utilisant un générateur

Partie 2 - Notions plus avancées

Cours 2

7. Structures de données

Les structures de données permettent de stocker des séries d’information et d’y accéder (plus ou moins) facilement et rapidement.

Les listes

Une collection d’éléments ordonnés référencé par un indice

animaux_favoris = [ "girafe", "chenille", "lynx" ]
fibonnaci = [ 1, 1, 2, 3, 5, 8 ]
stuff = [ 3.14, 42, "bidule", ["a", "b", "c"] ]

Accès à element particulier ou a une “tranche”

animaux_favoris[1]      ->  "chenille"
animaux_favoris[-2:]    ->  ["chenille", "lynx"]

Longueur

len(animaux_favoris)    -> 3

Tester qu’un élément est (ou n’est pas) dans une liste

"lynx" in animaux_favoris   # -> True
"Mewtwo" not in animaux_favoris   # -> True
animaux_favoris = [ "girafe", "chenille", "lynx" ]

Iteration

for animal in animaux_favoris:
    print(animal + " est un de mes animaux préférés !")

Iteration avec index

print("Voici la liste de mes animaux préférés:")
for i, animal in enumerate(animaux_favoris):
    print(str(i+1) + " : " + animal)
animaux_favoris = [ "girafe", "chenille", "lynx" ]

Modification d’un élément

animaux_favoris[1] = "papillon"

Ajout à la suite, contatenation

animaux_favoris.append("coyote")

Insertion, concatenation

animaux_favoris.insert(1, "sanglier")
animaux_favoris += ["lion", "moineau"]

Exemple de manip classique : filtrer une liste pour en construire une nouvelle

animaux_favoris = [ "girafe", "chenille", "lynx" ]

# Création d'une liste vide
animaux_starting_with_c = []

# J'itère sur la liste de pokémons favoris
for animal in animaux_favoris:

   # Si le nom de l'animal actuel commence par c
   if animal.startswith("c"):

      # Je l'ajoute à la liste
      animaux_starting_with_B.append(animal)

À la fin, animaux_starting_with_c contient:

["girafe"]

Transformation de string en liste

"Hello World".split()    -> ["Hello", "World"]

Transformation de liste en string

' | '.join(["a", "b", "c"])      -> "a | b | c"

Les dictionnaires

Une collection non-ordonnée (apriori) de clefs a qui sont associées des valeurs

phone_numbers = { "Alice":   "06 93 28 14 03",
                  "Bob":     "06 84 19 37 47",
                  "Charlie": "04 92 84 92 03"  }

Accès à une valeur

phone_numbers["Charlie"]        -> "04 92 84 92 03"
phone_numbers["Marius"]           -> KeyError !
phone_numbers.get("Marius", None) -> None

Modification d’une entrée, ajout d’une nouvelle entrée

phone_numbers["Charlie"] = "06 25 65 92 83"
phone_numbers["Deborah"] = "07 02 93 84 21"

Tester qu’une clef est dans le dictionnaire

"Marius" in phone_numbers    # -> False
"Bob" not in phone_numbers # -> False
phone_numbers = { "Alice":   "06 93 28 14 03",
                  "Bob":     "06 84 19 37 47",
                  "Charlie": "04 92 84 92 03"  }

Iteration sur les clefs

for prenom in phone_numbers:     # Ou plus explicitement: phone_numbers.keys()
    print("Je connais le numéro de "+prenom)

Iteration sur les valeurs

for phone_number in phone_numbers.values():
    print("Quelqu'un a comme numéro " + phone_number)

Iterations sur les clefs et valeurs

for prenom, phone_number in phone_numbers.items():
    print("Le numéro de " + prenom + " est " + phone_number)

Construction plus complexes

Liste de liste, liste de dict, dict de liste, dict de liste, …

contacts = { "Alice":  { "phone": "06 93 28 14 03",
                         "email": "alice@megacorp.eu" },

             "Bob":    { "phone": "06 84 19 37 47",
                         "email": "bob.peterson@havard.edu.uk" },

             "Charlie": { "phone": "04 92 84 92 03" } }
contacts = { "Alice":  { "phone": "06 93 28 14 03",
                         "email": "alice@megacorp.eu" },

             "Bob":    { "phone": "06 84 19 37 47",
                         "email": "bob.peterson@harvard.edu.uk" },

             "Charlie": { "phone": "04 92 84 92 03" } }

Recuperer le numero de Bob

contacts["Bob"]["phone"]   # -> "06 84 19 37 47"

Ajouter l’email de Charlie

contacts["Charlie"]["email"] = "charlie@orange.fr"

Ajouter Deborah avec juste une adresse mail

contacts["Deborah"] = {"email": "deb@hotmail.fr"}

Les sets

Les sets sont des collections d’éléments unique et non-ordonnée

chat = set(["c", "h", "a", "t"])        # -> {'h', 'c', 'a', 't'}
chien = set(["c", "h", "i", "e", "n")   # -> {'c', 'e', 'i', 'n', 'h'}
chat - chien                            # -> {'a', 't'}
chien - chat                            # -> {'i', 'n', 'e'}
chat & chien                            # -> {'h', 'c'}
chat | chien                            # -> {'c', 't', 'e', 'a', 'i', 'n', 'h'}
chat.add("z")                           # ajoute `z` à `chat`

Les tuples

Les tuples permettent de stocker des données de manière similaire à une liste, mais de manière non-mutable. Generalement itérer sur un tuple n’a pas vraiment de sens…

Les tuples permettent de grouper des informations ensembles. Typiquement : des coordonnées de point.

xyz = (2,3,5)
xyz[0]        # -> 2
xyz[1]        # -> 3
xyz[0] = 5    # -> Erreur!

Autre exemple dictionnaire.items() renvoie une liste de tuple (clef, valeur) :

[ (clef1, valeur1), (clef2, valeur2), ... ]

List/dict comprehensions

Les “list/dict comprehensions” sont des syntaxes particulière permettant de rapidement construire des listes (ou dictionnaires) à partir d’autres structures.

Syntaxe (list comprehension)

[ new_e for e in liste if condition(e) ]

Exemple (list comprehension)

Carré des entiers impairs d’une liste

[ e**2 for e in liste if e % 2 == 1 ]

List/dict comprehensions

Les “list/dict comprehensions” sont des syntaxes particulière permettant de rapidement construire des listes (ou dictionnaires) à partir d’autres structures.

Syntaxe (dict comprehension)

{ new_k:new_v for k, v in d.items() if condition(k, v) }

Exemple (dict comprehension)

{ nom: age-20 for nom, age in ages.items() if age >= 20 }

Générateurs

(Pas vraiment une structure de données, mais c’est lié aux boucles …)

  • Une fonction qui renvoie des résultats “au fur et à mesure” qu’ils sont demandés …
  • Se comporte comme un itérateur
  • Peut ne jamais s’arrêter …!
  • Typiquement, évite de créer des listes intermédiaires

exemple SANS generateur

mes_animaux = { "girafe": 300,    "coyote": 50,
                 "chenille": 2,       "cobra": 45
                 # [...]
               }

def au_moins_un_metre(animaux):

    output = []
    for animal, taille in animaux.items():
        if taille >= 100:
            output.append(animal)

    return output

for animal in au_moins_un_metre(mes_animaux):
   ...

exemple AVEC generateur

mes_animaux = { "girafe": 300,    "coyote": 50,
                 "chenille": 2,       "cobra": 45
                 # [...]
               }

def au_moins_un_metre(animaux):

    for animal, taille in animaux.items():
        if taille >= 100:
            yield animal

for animal in au_moins_un_metre(mes_animaux):
   ...

Il n’est pas nécessaire de créer la liste intermédiaire output

Un autre exemple

def factorielle():

   n = 1
   acc = 1

   while True:
       acc *= n
       n += 1

       yield acc

Ex.7 Structures de données

7.1 : Écrire une fonction qui retourne le plus grand élément d’une liste (ou d’un set) de nombres, et une autre fonction qui retourne le plus petit. Par exemple, plus_grand([5, 9, 12, 6, -1, 4]) retournera 12.

assert plus_grand([5, 9, 12, 6, -1, 4]) == 12
assert plus_grand([-6, -19, -2]) == -2
assert plus_petit([5, 9, 12, 6, -1, 4]) == -1
assert plus_petit([-6, -19, -2]) == -19

7.2 : Écrire une fonction qui retourne le mot le plus long parmis une liste de mot donnée en argument.

assert plus_long(["Paris", "Amsterdam", "Londres"]) == "Amsterdam"
assert plus_long(["Choucroute", "Pizza", "Tarte flambée"]) == "Tarte flambée"

7.3 : Écrire une fonction qui calcule la somme d’une liste de nombres.

assert somme([3, 4, 5]) == 12
assert somme([0, 7, -3]) == 4

7.4 : Écrire une fonction qui prends en argument un chemin de fichier comme “/usr/bin/toto.py” et extrait le nom du fichier, c’est à dire “toto”. On pourra utiliser la méthode chaine.split(caractere) des chaînes de caractère.

7.5.1 : Récuperer le dictionnaire d’exemple auprès du formateur (example_dict.py) et boucler sur ce dictionnaire pour afficher quelque chose comme:

Sebastian est né.e en 1979
Barclay est né.e en 2000
Vivien est né.e en 1955
...
example_dict=[{'name': 'Sebastian', 'email': 'Donec.felis.orci@consectetueripsumnunc.edu', 'country': '1979'}, {'name': 'Barclay', 'email': 'aliquet.metus.urna@neceleifend.co.uk', 'country': '2000'}, {'name': 'Vivien', 'email': 'pharetra@a.com', 'country': '1955'}, {'name': 'Britanney', 'email': 'eu.tellus.Phasellus@arcuvelquam.ca', 'country': '1961'}, {'name': 'Reese', 'email': 'tortor.dictum.eu@egestasSed.ca', 'country': '1951'}, {'name': 'Keegan', 'email': 'libero.nec@cursuset.co.uk', 'country': '1998'}, {'name': 'Ezekiel', 'email': 'tempus.mauris.erat@aclibero.org', 'country': '1951'}, {'name': 'Odessa', 'email': 'massa.Quisque.porttitor@felis.net', 'country': '1925'}, {'name': 'Elijah', 'email': 'luctus.vulputate.nisi@nunc.com', 'country': '1963'}, {'name': 'Hilel', 'email': 'lectus.pede.et@aliquetsem.ca', 'country': '1982'}, {'name': 'Callie', 'email': 'et.euismod.et@aliquetmagnaa.net', 'country': '1984'}, {'name': 'India', 'email': 'Duis.sit.amet@Phaselluslibero.com', 'country': '1938'}, {'name': 'Lane', 'email': 'amet@turpis.ca', 'country': '1922'}, {'name': 'Alexis', 'email': 'sagittis.placerat@nibhdolor.net', 'country': '1927'}, {'name': 'Micah', 'email': 'lorem.eget.mollis@SeddictumProin.com', 'country': '1914'}, {'name': 'Rigel', 'email': 'sollicitudin@eratinconsectetuer.org', 'country': '1941'}, {'name': 'Avram', 'email': 'tincidunt.vehicula@vulputate.org', 'country': '1919'}, {'name': 'Dieter', 'email': 'ornare.lectus.justo@Integeridmagna.org', 'country': '1937'}, {'name': 'Sarah', 'email': 'cubilia.Curae.Phasellus@non.net', 'country': '1946'}, {'name': 'Graham', 'email': 'elit.Curabitur.sed@maurisIntegersem.edu', 'country': '1931'}, {'name': 'Daquan', 'email': 'fermentum.convallis.ligula@porttitorinterdum.co.uk', 'country': '1934'}, {'name': 'Nell', 'email': 'purus@lectusconvallisest.org', 'country': '1997'}, {'name': 'Ocean', 'email': 'ut@Nuncquisarcu.net', 'country': '2006'}, {'name': 'Cruz', 'email': 'Aenean.euismod.mauris@idmollisnec.edu', 'country': '1950'}, {'name': 'Hyacinth', 'email': 'amet@Nunc.edu', 'country': '1929'}]

7.5.2 : Transformer le programme précédent pour n’afficher que les personnes ayant une adresse mail finissant par .edu.

7.6 : Ecrire une fonction compte_lettres qui prends en argument une (grande) chaîne de caractère et retourne un dictionnaire avec un compte des occurences des lettres. Par exemple compte_lettres("hello") retournera {"h":1, "l": 2, "o": 1, "e":1 }. Utiliser cette fonction sur Lorem Ipsum (“Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt […]")

7.7 : Écrire une fonction qui retourne seulement les entiers pairs d’une liste

7.8 : Écrire une fonction qui permet de trier une liste (ou un set) d’entiers

7.9 : En une seule ligne de code, générer la matrice suivante :

[ [ 0, 1, 2, 3,  4  ],
  [ 0, 2, 4, 6,  8  ],
  [ 0, 3, 6, 9,  12 ],
  [ 0, 4, 8, 12, 16 ] ]

7.10 : Réécrire la fonction somme du 8.2, mais cette fois sans utiliser de variable intermédiaire (utiliser la récursivité)

7.11 : Ecrire un générateur carre() qui genere la suite 1, 4, 9, 16, … Utiliser ce générateur pour afficher les carrés jusqu’à ce qu’une valeur dépasse 200.

7.12 : Ecrire un générateur fibonnaci qui genere la suite de fibonnaci 0, 1, 1, 2, 3, 5, 8, … Utiliser ce générateur pour afficher les valeurs jusqu’à ce qu’elles dépassent 500.

8. Programmation et algorithmique - récapituler

Programmation impérative / procédurale

  • Comme une recette de cuisine qui manipule de l’information
  • Une suite d’opération à effectuer
  • Différents concepts pour construire ces opérations:
    • des variables
    • des fonctions
    • des conditions
    • des boucles
    • des structures de données (listes, dictionnaires)

Variables

x = "Toto"
x = 40
y = x + 2
print("y contient " + str(y))

Fonctions

def aire_triangle(base, hauteur):
    calcul = base * hauteur / 2
    return calcul

A1 = aire_triangle(3, 5)      # -> A1 vaut 15 !
A2 = aire_triangle(4, 2)      # -> A2 vaut 8 !
  • Indentation
  • Arguments (peuvent être optionnels si on spécifie une valeur par défaut)
  • Variables locales
  • return pour pouvoir récupérer un résultat depuis l’extérieur
  • Appel de fonction

Conditions

def aire_triangle(base, hauteur):

    if base < 0 or hauteur < 0:
        print("Il faut donner des valeurs positives!")
        return -1

    calcul = base * hauteur / 2
    return calcul
  • Indentation
  • Opérateurs (==, !=, <=, >=, and, or, not, in, …)
  • Mot clefs if, elif, else

Listes, dictionnaires et boucles

breakfast = ["Spam", "Eggs", "Bacon", "Spam"]
breakfast.append("Coffee")

print("Au petit dej' je mange: ")
for stuff in breakfast:
    print(stuff)
ingredients_gateau = {"farine": 200,
                      "beurre": 100,
                      "chocolat": 150}

for ingredient, qty in ingredients_gateau.items():
    print("J'ai besoin de " + str(qty) + "g de " + ingredient)

Algorithmes simples : max

def max(liste_entiers):
    if liste_entiers == []:
        print("Erreur, peut pas calculer le max d'une liste vide")
        return None

    m = liste_entiers[0]
    for entier in liste_entiers:
        if m < entier:
            m = entier

    return m

Algorithmes simples : filtrer une liste

def pairs(liste_entiers):

    resultat = []

    for entier in liste_entiers:
        if entier % 2 == 0:
            resultat.append(entier)

    return resultat

9. Erreurs et exceptions

En Python, lorsqu’une erreur se produit ou qu’un cas particulier empêche (a priori) la suite du déroulement normal d’un programme ou d’une fonction, une exception est déclenchée

Attention : différent des erreurs de syntaxe

Exemple d’exceptions

  • Utiliser une variable qui n’existe pas

  • Utiliser int() sur quelque chose qui ne peut pas être converti en entier

  • Diviser un nombre par zero

  • Diviser un nombre par une chaine de caractère

  • Tenter d’accéder à un élément d’une liste qui n’existe pas

  • Tenter d’ouvrir un fichier qui n’existe pas ou qu’on ne peut pas lire

  • Tenter de télêcharger des données sans être connecté à internet

  • etc…

  • Une exception a un type (c’est un objet d’un classe d’exception -> cf. Partie 3):

    • Exception, ValueError, IndexError, TypeError, ZeroDivisionError, …
  • Lorsqu’une exception interrompt le programme, l’interpréteur affiche la stacktrace (TraceBack) qui contient des informations pour comprendre quand et pourquoi l’exception s’est produite.

Traceback (most recent call last):
  File "coucou.py", line 3, in <module>
    print(coucou)
NameError: name 'coucou' is not defined
# python3 test_int.py

Tapez un entier entre 1 et 3: truc

Traceback (most recent call last):
  File "test_int.py", line 8, in <module>
    demander_nombre()
  File "test_int.py", line 4, in demander_nombre
    r = int(input("Tape un entier entre 1 et 3: "))
ValueError: invalid literal for int() with base 10: 'truc'

Souvent une exception est due à une entrée utilisateur incorrecte (comme ici) mais pas toujours.

raise

Il est possible de déclencher ses propres exceptions à l’aide de raise

def max(liste_entiers):
    if liste_entiers == []:
        raise Exception("max() ne peut pas fonctionner sur une liste vide!")

(Ici, le type utilisé est le type générique Exception)

Autre exemple:

def envoyer_mail(destinataire, sujet, contenu):
    if '@' not in destinataire:
        raise Exception('Une adresse mail doit comporter un @ !')

(Ici, le type utilisé est le type générique Exception)

try/except

De manière générale dans un programme, il peut y’avoir beaucoup de manipulation dont on sait qu’elles peuvent échouer pour un nombre de raisons trop grandes à lister …

Par exemple : écrire dans un fichier

  • Est-ce que le programme a la permission d’écrire dans ce fichier ?
  • Est-ce qu’aucun autre programme n’est en train d’écrire dans ce fichier ?
  • Est-ce qu’il y a assez d’espace disque libre ?
  • Si je commence à écrire, peut-être vais-je tomber sur un secteur disque deffectueux

Autre exemple : aller chercher une information sur internet

  • Est-ce que je suis connecté à Internet ?
  • Est-ce que la connection est suffisament stable et rapide ?
  • Est-ce que le programme a le droit d’effectuer d’envoyer des requêtes ?
  • Est-ce qu’un firewall va bloquer ma requête ?
  • Est-ce que le site que je veux contacter est disponible actuellement ?
  • Est-ce que le certificat SSL du site est à jour ?
  • Quid de si la connexion est perdue en plein milieu de l’échange ?

En Python, il est courant d'« essayer » des opérations puis de gérer les exceptions si elles surviennent.

On utilise pour cela des try: ... except: ....

Exemple

reponse = input("Entrez un entier svp !")

try:
    n = int(reponse)
except:
    raise Exception("Ce n'est pas un entier !")

Utilisation différente

reponse = input("Entrez un entier svp !")

try:
    n = int(reponse)
except:
    n = -1
while True:
    reponse = input("Entrez un entier svp !")

    try:
        n = int(reponse)
        break
    except:
        # Faire en sorte de boucler pour reposer la question à l'utilisateur ...
        print("Ce n'est pas un entier !")
        continue

Autre exemple (inhabituel):

On peut utiliser les exception comme une sorte de if ou inversement

def can_be_converted_to_int(stuff):
    try:
        int(stuff)
    except:
        return False

    return True

can_be_converted_to_int("3")    # -> True
can_be_converted_to_int("abcd") # -> False

The “python way”

« Better to ask forgiveness than permissions »

Traduction “on essaye et puis on voit et on gère les dégats”. (ça se discute)

Assertions

Il est possible d’utiliser des assertions pour expliciter certaines hypothèses faites pendant l’écriture du code. Si elles ne sont pas remplies, une exception est déclenchée.

Un peu comme un "if not condition raise error".

def max(liste_entiers):
    assert liste_entiers != [], "max() ne peut pas fonctionner sur une liste vide!"

(assert toto est équivalent à if not toto: raise Exception())

def distance(x=0, y=0):
    assert isinstance(x, (int, float)), "Cette fonction ne prends que des int ou float en argument !"
    assert isinstance(y, (int, float)), "Cette fonction ne prends que des int ou float en argument !"

    return racine_carree(x*x + y*y)
def some_function(n):
    assert n, "Cette fonction n'accepte pas 0 ou None comme argument !"
    assert n % 2 == 0, "Cette fonction ne prends que des entiers pairs en argument !"

    [...]

Assertions et tests unitaires

En pratique, l’une des utilisations les plus courantes de assert est l’écriture de tests unitaires qui permettent de valider qu’une fonction marche dans tous les cas (et continue à marcher si on la modifie)

Dans votre application:

def trier(liste_entiers):
    # on définie le comportement de la fonction

Dans les tests (fichier à part):

assert trier([15, 8, 4, 42, 23, 16]) == [4, 8, 15, 16, 23, 42]
assert trier([0, 82, 4, -21, 2]) == [-21, 0, 2, 4, 82]
assert trier([-7, -3, 0]) == [-7, -3, 0]
assert trier([]) == []

Cf. Chapitre 19

Calcul du max d’un liste d’entier : plusieurs approches !

Attention : dans les exemples suivant je dois penser au cas où resultat peut valoir None

Je soupçonne fortemment que ma_liste puisse ne pas être une liste ou puisse être vide

Soit je teste explicitement avant pour être sur (moins pythonique) !

if not isinstance(ma_liste, list) or ma_liste == []:
    resultat = None
else:
    resultat = max(ma_liste)

Ça devrait marcher, mais j’ai un doute …

Soit j’essaye et je gère les cas d’erreur (plus pythonique)!

try:
    resultat = max(ma_liste)
except ValueError as e:
    print("Warning : peut-etre que ma_liste n'etait pas une liste non-vide ?")
    resultat = None

Soit j’assert le test pour laisser la fonction appelante le soin de gérer l’entrée correctement

Normalement ma_liste est une liste non-vide, sinon il y a un très gros problème avant dans le programme…

assert isinstance(ma_liste, list) and ma_liste != []

resultat = max(ma_liste)

Dans ce cas la fonction

10. Fichiers

Lire “brutalement”

mon_fichier = open("/etc/passwd", "r")
contenu_du_fichier = mon_fichier.readlines()
mon_fichier.close()

for ligne in contenu_du_fichier:
    print(ligne)

Attention à bien distinguer:

  • le nom du fichier (passwd) et son chemin d’accès absolu (/etc/passwd)
  • le vrai fichier qui existe sur le disque
  • la variable / objet Python (dans l’exemple, nommée f) qui est une interface pour interagir avec ce fichier

Lire, avec une “gestion de contexte”

with open("/etc/passwd", "r") as mon_fichier:
    contenu_du_fichier = mon_fichier.readlines()

for ligne in contenu_du_fichier:
    print(ligne)

Explications

  • open("fichier", "r") ouvre un fichier en lecture
  • with ... as ... ouvre un contexte, à la fin duquel le fichier sera fermé automatiquement
  • f.readlines() permet d’obtenir une liste de toutes les lignes du fichier

Lire

  • f.readlines() renvoie une liste contenant les lignes une par une

  • f.readline() renvoie une ligne du fichier à chaque appel.

  • f.read() renvoie une (grande) chaĩne contenant toutes les lignes concaténées

  • Attention, si je modifie la variable contenu_du_fichier … je ne modifie pas vraiment le fichier sur le disque ! Pour cela, il faut explicitement demander à écrire dans le fichier.

Ecrire

En remplacant tout !

with open("/home/alex/test", "w") as f:
    f.write("Plop")

À la suite (« append »)

with open("/home/alex/test", "a") as f:
    f.write("Plop")

Fichiers et exceptions

try:
    with open("/some/file", "r") as f:
        lines = f.readlines()
except:
    raise Exception("Impossible d'ouvrir le fichier en lecture !")

Un autre exemple

try:
    with open("/etc/shadow", "r") as f:
        lines = f.readlines()
except PermissionError:
    raise Exception("Pas le droit d'ouvrir le fichier !")
except FileNotFoundError:
    raise Exception("Ce fichier n'existe pas !")

Note “technique” sur la lecture des fichiers

  • Il y a un “curseur de lecture”. On peut lire petit morceaux par petit morceaux … une fois arrivé au bout, il n’y a plus rien à lire, il faut replacer le curseur si on veut de nouveau lire.
f = open("/etc/passwd")
print(f.read())  # ---> Tout plein de choses
print(f.read())  # ---> Rien !
f.seek(0)        # On remet le curseur au début
print(f.read())  # ---> Tout plein de choses !

Ex.10 Fichiers

10.1 : Créer un fonction liste_users qui lit le fichier /etc/passwd et retourne la liste des utilisateurs ayant comme shell de login /bin/bash.

10.2 : Dans le code Python, écrire un modèle d’email comme:

modele = """
Bonjour {prenom} !
Voici en pièce jointe les billets pour votre voyage en train vers {destination}.
"""

Ecrire une fonction generer_email qui remplace dans modele les chaines {prenom}et {destination} par des arguments fourni à la fonction, et enregistre le résultat dans un fichier email_{prenom}.txt. Par exemple, generer_email("Alex", "Strasbourg") générera le texte et sauvegardera le résultat dans email_Alex.txt.

10.3 : Écrire une fonction qui permet d’afficher un fichier sans les commentaires et les lignes vides. Spécifier le caractère qui symbolise le début d’un commentaire en argument de la fonction. (Ou pourra utiliser la méthode strip() des chaînes de caractère pour identifier plus facilement les lignes vides)

11. Librairies

L’une des puissances de python vient de l’écosystème de librairie disponibles.

Librairie / bibliothèque / module : un ensemble de fonctionnalité déjà pensés et éprouvées, prêtes à l’emploi.

Syntaxes d’import

import un_module          # -> Importer tout un module
un_module.une_fonction()  # -> Appeler la fonction une_function()
                          #    du module

Exemple

import math

math.sqrt(2)   # -> 1.4142135623730951

Importer juste des choses précises

from un_module import une_fonction, une_autre

une_fonction(...)

Exemple

from math import sqrt, sin, cos

sqrt(2)   # -> 1.4142135623730951

Exemple : json

Le JSON est un format de fichier qui permet de décrire des données numériques complexe et imbriquées pour le stocker ou le transférer. Il s’agit du format de données dominant aujourd’hui sur le web. Il est utilisé dans tous les langages et Python intègre à l’installation une librairie pour le manipuler.

A noter également qu’il est quasiment isomorphe à un dictionnaire Python.

{
    "mailman": {
        "branch": "master",
        "level": 2,
        "state": "working",
        "url": "https://github.com/yunohost-apps/mailman_ynh",
        "flags": [ "mailing-list", "lightweight" ]
    },
    "mastodon": {
        "branch": "master",
        "level": 3,
        "state": "inprogress",
        "url": "https://github.com/YunoHost-Apps/mastodon_ynh",
        "flags": [ "social network", "good-UX" ]
    }
}

La fonction principale de la librairie est loads() qui tranforme une chaîne de caractère au format JSON en dictionnaire.

import json

# Ouvrir, lire et interpreter un fichier json
with open("applications.json") as f:
    j = json.loads(f.read())


# Trouver l'état de l'application mailman
j["mailman"]["state"]     # -> "working"

Exemple : requests pour un besoin web simple (bas niveau)

Envoyer une requête HTTP et récuperer la réponse (et potentiellement le contenu d’une page).

import requests

r = requests.get("https://en.wikipedia.org/wiki/Python", timeout=30)

print(r.status_code)    # -> 200 si ça a marché
print(r.text)           # -> Le contenu de la page

Exemple : csv

import csv

# Ouvrir et lire les lignes d'un fichier csv
with open("table.csv") as f:
    table = csv.reader(f, delimiter='|')
    for row in table:
        print(row[1]) # Afficher le 2eme champ
        print(row[3]) # Afficher le 4eme champ

with open("newtable.csv", "w") as f:
    newtable = csv.write(f, delimiter=",")
    newtable.writerow(["Alice", 32, "Lyon"])
    newtable.writerow(["Bob", 29, "Bordeaux"])

Exemple : sys

permet d’interagir / de s’interfacer avec le systeme (librairie système commune à toutes les plateforme)

Par exemple:

import sys

sys.stdout   # La sortie standard du programme
sys.path     # Les chemins depuis lesquels sont chargés les imports
sys.argv     # Tableau des arguments passés en ligne de commande
sys.exit(1)  # Sortir du programme avec un code de retour de 1

Exemple : os

os permet d’interagir avec le système d’exploitation pour réaliser différent type d’action… Certaines étant spécifiques à l’OS en question (Linux, Windows, …)

Quelques exemples :

import os
os.listdir("/etc/")            # Liste les fichiers dans /etc/
os.path.join("/etc", "passwd") # Génère un chemin à partir de plusieurs parties
os.system("touch /etc/toto")   # (à éviter) Execute une commande "brute"

Voir aussi : copie ou suppression de fichiers, modification des permissions, …

Exemple : argparse

  • Du vrai parsing d’argument en ligne de commande
  • (Un peu long à initialiser mais puissant)

Exemple concurrent: docopt

Sert à la même chose que argparse mais beaucoup plus rapide à utiliser ! Docopt analyse la documentation du module pour deviner les arguments !

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__)
    print(arguments)

Ensuite python naval_fate.py ship new monbateau --speed=15 renvoie un dictionnaire d’arguments du type:

{'--drifting': False,    'mine': False,
 '--help': False,        'move': True,
 '--moored': False,      'new': True,
 '--speed': '15',        'remove': False,
 '--version': False,     'set': False,
 '<name>': ['Guardian'], 'ship': True,
 '<x>': '100',           'shoot': False,
 '<y>': '150'}

On peut les utiliser pour paramétrer le programme CLI !

Exemple : subprocess

subprocess peut typiquement être utilisé pour lancer des commandes en parallèle du programme principal et récupérer leur résultat.

out = subprocess.check_output(["echo", "Hello World!"])
print(out)    # -> Affiche 'Hello World'
  • check_output : recupère la sortie d’une commande
  • check_call : verifie que la commande a bien marché (code de retour ‘0’) ou declenche une exception
  • Popen : méthode plus bas niveau

Cf. Partie sur l’execution concurrente en Python

Moar ?

  • Debian packages : python-*
  • Python package manager : pip

Exemples

  • JSON, XML, HTML, YAML, …
  • Regular expressions
  • Logging, Parsing d’options, …
  • Internationalisation
  • Templating
  • Plots, LDAP, …

Gestionnaire de paquet pip

  • Gestionnaire de paquet / modules Python
  • PIP : “Pip Install Packages”
  • PyPI : Python Package Index : visitez https://pypi.org

(à ne pas confondre avec Pypy un interpreter python écrit en Python)

  • Installer un paquet :
    • pip3 install <paquet>
  • Rechercher un paquet :
    • pip3 search <motclef>
  • Installer une liste de dépendances :
    • pip3 install -r requirements.txt
  • Lister les paquets installés
    • pip3 list, pip3 freeze
  • Les paquets installés sont dans /usr/lib/python*/dist-packages/

Virtualenv

  • Environnement virtuel
  • Isoler des paquets / dépendances pour utiliser des versions spécifiques
# La premiere fois :
sudo apt install python3-virtualenv virtualenv

# Creation d'un virtualenv 'venv'
virtualenv -p python3 venv
source venv/bin/activate

# Installation de dependances
pip3 install <une dependance...>
pip3 install <une autre dependance...>


# On développe, on teste, etc....


# Si on a fini et/ou que l'on veut "sortir" du virtualenv
deactivate

Documentation pour toutes les plateformes : https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/

Outils plus récents Pipenv et Conda

Pip et les virtualenv sont les outils classique pour gérer les dépendances en Python mais il existe également de nouvelles solutions moins classique

  • Pipenv un outil rassemblant pip et virtualenv pour simplifier le processus de travail.
  • Conda un gestionnaire de dépendances multiplateforme.

Installer Pip et Virtualenv sur Windows

Ex.11 Librairies

Les énoncés des exercices suivants peuvent être un peu plus ouverts que les précédents, et ont aussi pour objectifs de vous inciter à explorer la documentation des librairies (ou Internet en général…) pour trouver les outils dont vous avez besoin. Il existe de nombreuse façon de résoudre chaque exercice.

JSON, requests et argparse

11.1.1 : Télécharger le fichier https://app.yunohost.org/apps.json (avec votre navigateur ou wget par exemple). Écrire une fonction qui lit ce fichier, le charge en tant que données json. Écrire une autre fonction capable de filter le dictionnaire pour ne garder que les apps d’un level supérieur à n donné en argument. Écrire une fonction similaire pour le status (working, inprogress, notworking).

11.1.2 : Améliorer le programme précédent pour récupérer la liste directement depuis le programme avec requests. (Ajoutez une instruction pour s’assurer que le code du retour est bien 200 avant de continuer).

11.1.3 : Exporter le résultat d’un filtre (par exemple toutes les applications avec level >= 7) dans un fichier json.

11.1.4 : À l’aide de la librairie argparse, paramétrez le tri à l’aide d’un argument donné en ligne de commande. Par exemple: python3 filtre_apps.py --level 7 exportera dans “result.json” seulement les apps level >= 7.

CSV

11.2.1 : Récupérer le fichier de données CSV auprès du formateur, le lire, et afficher le nom des personnes ayant moins de 24 ans. Pour ce faire, on utilisera la librarie csv.

11.2.2 : Trier les personnes du fichier CSV par année de naissance et enregistrer une nouvelle version de ce fichier avec seulement le nom et l’année de naissance. Pour trier, on pourra utiliser sorted et son argument key.

Random

11.3 : Écrire une fonction jets_de_des(N) qui simule N lancés de dés 6 et retourne le nombre d’occurence de chaque face dans un dictionnaire. Par exemple : {1: 13, 2:16, 3:12, ... }. Calculer ensuite la frequence (nb_occurences / nb_lancés_total) pour chaque face. Testez avec un N grand et en déduire si votre dé virtuel est pipé ou non.

11.4 : Écrire un fonction create_tmp_dir qui choisi un nombre au hasard entre 0 et 100000 puis créer le dossier /tmp/tmp-{lenombre} et retourne le nom du dossier ainsi créé. On pourra utiliser la librairie random pour choisir un nom aléatoire, et os.system ou subprocess.check_call pour créer le dossier.

Interaction avec le systeme de fichier

11.5.1 : Écrire une fonction qui permet de trouver récursivement dans un dossier tous les fichiers modifiés il y a moins de 5 minutes.

11.5.2 : À l’aide d’une deuxième fonction permettant d’afficher les n dernières lignes d’un fichier, afficher les 10 dernières lignes des fichiers récemment modifiés dans /var/log

Interaction avec l’OS

11.6 : Écrire une fonction qui récupère l’utilisation actuelle de la mémoire RAM via la commande free. La fonction retournera une utilisation en pourcent.

11.7 : Écrire une fonction qui renvoie les 3 processus les plus gourmands actuellement en CPU, et les 3 processus les plus gourmands en RAM (avec leur consommation actuelle, chacun en CPU et en RAM)

12. Principes de développement - Partie 2

Documentation

Pour les librairies (et Python en général) :

  • docs.python.org
  • devdocs.io
  • stack overflow …
  • doc strings !!

Pour votre code :

  • nom de variables, fonctions, argument !!!
  • commentaires, doc strings
  • gestionnaire de version
  • generation de doc automatique ?

Faire du “bon code”

La lisibilité est la priorité numéro 1

Un programme est vivant et évolue. Mieux vaut un programme cassé mais lisible (donc débuggable) qu’un programme qui marche mais incompréhensible (donc fragile et/ou qu’on ne saura pas faire évoluer)

(c.f. Guido van Rossum chez Dropbox)

Autrement dit : la lisibilité pour vous et vos collègues a énormément d’importance pour la maintenabilité et l’évolution du projet

  • Keep It Simple
  • Sémantique : utiliser des noms de variables et de fonctions concis et pertinents
  • Commentaires : lorsque c’est nécessaire, pour démystifier ce qu’il se passe
  • Modularité : découper son programme en fonctions qui chacune résolvent un sous-problème
  • Couplage faible : garder ses fonctions autant que possibles indépendantes, limiter les effets de bords
  • Prendre le temps de refactoriser quand nécessaire
    • si je répète plusieurs fois les mémes opérations, peut-être définir une nouvelle fonction
    • si le contenu d’une variable ou d’une fonction change, peut-être changer son nom
  • Ne pas abuser des principes précédents
    • trop d’abstractions tue l’abstraction
    • tout ça viens avec le temps et l’expérience

How to write good code

Conventions de nommages des variables, fonctions et classes

Variables et fonctions en snake case : nom_de_ma_variable

Constantes globales en macro case: NOM_DE_MA_CONSTANTE

Nom de classes en upper camel case : NomDeMaClasse

Syntaxe, PEP8, linters

  • Le style d’écriture de python est standardisé via la norme PEP8
  • Il existe des “linter” pour détecter le non-respect des conventions (et également certaines erreurs logiques)
    • Par exemple flake8, pylint
  • Intégration possible dans vim et autres IDE…
  • autopep8 ou black permettent de corriger un bon nombre de problème automatiquement

Ex.12 Outils pour développer

12.1 - Utiliser pip3 pour trouver quelle est le numéro de version du package requests installé

12.2 - Rechercher avec pip3 si les paquets flake8 et autopep8 existent. Installez-les.

12.3 - Utilisez flake8 sur un code que vous avez écrit récemment (disons d’au moins 30 ou 40 lignes !). Étudiez les erreurs et warnings rapportées par flake, et essayer les corriger manuellement. Si certains warnings vous semblent trop aggressif, utiliser --ignore pour spécifier des codes d’erreurs à ignorer.

12.4.1 - Sur un autre code relativement mal formatté, utiliser autopep8 pour tenter d’ajuster automatiquement le formattage du code. Sauvegarder la sortie fournie par autopep8 dans un autre fichier “version 2” et comparer le fichier initial avec le fichier de sortie à l’aide de diff ou de git diff --no-index file1 file2.

12.4.2 - Le nouveau fichier est-il exempt de problèmes d’après flake8 ?

Bonus. ArgParse, utiliser des arguments en ligne de commande

argparse est une librairie python qui va notre permettre de créer simplement des interfaces en ligne de commandes.

import argparse

parser = argparse.ArgumentParser(description="This script does something.")
parser.add_argument("who", help="Who are you ?")
parser.add_argument("many", type=int)
args = parser.parse_args()
for i in range(args.many):
  print("Hello " + args.who)

On crée d’abord un parser avec:

parser = argparse.ArgumentParser(description="This script does something.")

Puis on le remplit avec les informations sur les arguments avec add_argument. On peut indiquer un argument positionnel, en le nommant juste, comme optionnel, avec - ou –

parser.add_argument("who", help="Who are you ?")
parser.add_argument("many", type=int)

argparse traite les données en entrée comme des chaines de caractère si un type n’est pas précisé. On peut le préciser tout simplement avec l’option type=(nom_du_type) On prend ensuite les arguments en entrée et on les parses avec parse_args:

args=parser.parse_args()

On a ainsi nos différents arguments. Ici, args.many, args.who

Reprendre l’exemple précédent et ajouter - devant le nom des argument. Que se passe t’il? Reprendre l’exemple, sauf que cette fois si l’utilisateur ne rentre rien, le programme affiche 3 fois Hello john.

Notes: notre parser est en fait un objet, tout comme ici args. args.many et args.who sont ainsi les attributs de l’objet args. Nous reviendrons sur la notion d’objet plus tard. ///// A supprimer ////

import argparse
parser = argparse.ArgumentParser(description="This script does something.")
parser.add_argument("--who", help="Who are you ?")
parser.add_argument("--many", type=int)
args = parser.parse_args()
for i in range(args.many):
  print("Hello " + args.who)

Bonus. Manipuler du XML en Python

XML : eXtensible Markup Language

  • Format très général pour structurer des informations dans un fichier texte
  • Défini et géré par le W3C (Consortium de standardisation et developpement du Web)
  • (X)HTML est un cas particulier de XML
  • ~historique ?… à tendance à être remplacé par JSON, YAML, bases SQL / noSQL, …

Quelques exemple courants:

  • un XML assez standard:
<?xml version="1.0" encoding="UTF-8"?>
<data>
    <apps>
        <app name="mailman" state="working" level="5" />
        <app name="wekan" state="inprogress" level="3" />
        <app name="nextcloud" state="working" level="7" />
        <app name="wordpress" state="working" level="7" />
        <app name="plex" state="notworking" />
    </apps>
</data>
  • du html:
<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>
  • Un documents LibreOffice
<?xml version="1.0" encoding="UTF-8"?>
<office:document-content office:version="1.2">
    [...]
    <office:body>
        <office:text>
            <text:p text:style-name="P1">
            Hello <text:span text:style-name="T1">world!</text:span>
            </text:p>
        </office:text>
    </office:body>
</office:document-content>

Un peu de vocabulaire

<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>
  • Balises : ouvrantes et fermantes, e.g. <p class="red"> et </p>
  • Attributs : par exemple class="red"
  • Noeuds éléments : caractérisés et délimités par des balises : head, body, script, p, …
    • peut contenir d’autres noeuds (éléments, texte, …) et donc créer un arbre
  • Noeuds texte : e.g. "Un morceau de texte"

XML : Approche DOM v.s. SAX

DOM : Document Object Model

  • Lecture et chargement initial de tout le document (peut être lourd pour les gros documents !)
  • Puis accès à tous les noeuds de l’arbre (~AST)
  • Approche classique et répandue (c.f. Javascript)

SAX : Simple API for XML

  • Lecture et analyse “au fur et à mesure”
  • Pas besoin de tout charger en mémoire
  • Adaptée aux gros documents

ElementTree

  • Best of both world ? (Mais moins de fonctionnalités avancées)
  • Simple à utiliser comme DOM, peut être aussi rapide que SAX

Quelques exemples de librairies

  • xml.tree.ElementTree : ElementTree API, inclue de base dans Python
  • lxml : Très complète, support de nombreux standard
  • BeautifulSoup : Interface simple, conçu pour parser du HTML contenant des erreurs
  • (et pleins d’autres …)
<html>
    <head>
        <meta charset="UTF-8">
        <link rel="stylesheet" href="style.css">
        <script src="lib.js"></script>
    </head>
    <body>
        <p class="text-bold">Un morceau de texte</p>
        <p class="text-emph">Un autre paragraphe</p>
    </body>
</html>

xml.tree.ElementTree

Parser / lire

from xml.etree import ElementTree as ET

root = ET.parse("monfichier.html")
body = root.find("body")

print(body[0])        # --> <Element 'p' at 0x12345>
print(body[0].tag)    # --> p
print(body[0].attrib) # --> {'class': 'text-bold'}
print(body[0].text)   # --> Un morceau de texte
print(list(body[0]))  # --> []  (pas d'elements fils)

# Trouver tout les <p> dans le body
tous_les_p = body.findall("p")

Construire / ecrire

from xml.etree import ElementTree as ET

root = ET.parse("monfichier.html")
body = root.find("body")

# Ajout d'un nouvel element dans <body>
# <p class="text-underline" id="new">Du texte en plus</p>

nouveau_p = ET.SubElement(body, "p", clas="text-underline", id="new")

root.write("monfichier_2.xml")

Parsing itératif avec lxml.etree.iterparse

  • ET.parse("fichier.xml") explose la RAM pour les gros fichiers.
  • Besoin d’une technique plus efficace
  • iterparse fourni un iterateur pour parser au fur et à mesure, qui plus est seulement sur des tags specifiques
from lxml import etree

iterator = etree.iterparse("fichier.xml", tag="p")

for event, element in iterator:
    # [...] traiter l'element

Ça consomme toujours de la RAM … besoin d’un trick en + … c.f. https://stackoverflow.com/questions/12160418

from lxml import etree

def clear_elem_and_ancestors(elem):
    elem.clear()
    for ancestor in elem.xpath('ancestor-or-self::*'):
        while ancestor.getprevious() is not None:
            del ancestor.getparent()[0]

iterator = etree.iterparse("fichier.xml", tag="p")

for event, element in iterator:
    # [...] traiter l'element
    clear_elem_and_ancestors(element)

Exercices Partie 2

Correction - Exercice 2

7.1

def retourner_plus_grand(liste):
    max=liste[0]
    for nombre in liste:
        if nombre>=a:
            max=nombre
    return max

7.2

def plus_grand_mot(liste):
    plus_grand_mot=liste[0]
    for mot in liste:
        if len(mot)>=len(a):
            plus_grand_mot=mot
    return plus_grand_mot

7.3

def somme(liste):
    total=0
    for total in liste:
        total+=nombre
    return total

7.4

def extraire_nom_fichier(path):
    liste=path.split("/") #['usr,'bin,'toto.py']
    nom_du_fichier=list[-1].split(".") #['toto','py']
    return liste[0]

# En un seule ligne
def extraire_nom_fichier_une_ligne(path):
 return path.split("/")[-1].split(".")[0]

7.5.1

example_dict=[{'name': 'Sebastian', 'email': 'Donec.felis.orci@consectetueripsumnunc.edu', 'country': '1979'}, {'name': 'Barclay', 'email': 'aliquet.metus.urna@neceleifend.co.uk', 'country': '2000'}, {'name': 'Vivien', 'email': 'pharetra@a.com', 'country': '1955'}, {'name': 'Britanney', 'email': 'eu.tellus.Phasellus@arcuvelquam.ca', 'country': '1961'}, {'name': 'Reese', 'email': 'tortor.dictum.eu@egestasSed.ca', 'country': '1951'}, {'name': 'Keegan', 'email': 'libero.nec@cursuset.co.uk', 'country': '1998'}, {'name': 'Ezekiel', 'email': 'tempus.mauris.erat@aclibero.org', 'country': '1951'}, {'name': 'Odessa', 'email': 'massa.Quisque.porttitor@felis.net', 'country': '1925'}, {'name': 'Elijah', 'email': 'luctus.vulputate.nisi@nunc.com', 'country': '1963'}, {'name': 'Hilel', 'email': 'lectus.pede.et@aliquetsem.ca', 'country': '1982'}, {'name': 'Callie', 'email': 'et.euismod.et@aliquetmagnaa.net', 'country': '1984'}, {'name': 'India', 'email': 'Duis.sit.amet@Phaselluslibero.com', 'country': '1938'}, {'name': 'Lane', 'email': 'amet@turpis.ca', 'country': '1922'}, {'name': 'Alexis', 'email': 'sagittis.placerat@nibhdolor.net', 'country': '1927'}, {'name': 'Micah', 'email': 'lorem.eget.mollis@SeddictumProin.com', 'country': '1914'}, {'name': 'Rigel', 'email': 'sollicitudin@eratinconsectetuer.org', 'country': '1941'}, {'name': 'Avram', 'email': 'tincidunt.vehicula@vulputate.org', 'country': '1919'}, {'name': 'Dieter', 'email': 'ornare.lectus.justo@Integeridmagna.org', 'country': '1937'}, {'name': 'Sarah', 'email': 'cubilia.Curae.Phasellus@non.net', 'country': '1946'}, {'name': 'Graham', 'email': 'elit.Curabitur.sed@maurisIntegersem.edu', 'country': '1931'}, {'name': 'Daquan', 'email': 'fermentum.convallis.ligula@porttitorinterdum.co.uk', 'country': '1934'}, {'name': 'Nell', 'email': 'purus@lectusconvallisest.org', 'country': '1997'}, {'name': 'Ocean', 'email': 'ut@Nuncquisarcu.net', 'country': '2006'}, {'name': 'Cruz', 'email': 'Aenean.euismod.mauris@idmollisnec.edu', 'country': '1950'}, {'name': 'Hyacinth', 'email': 'amet@Nunc.edu', 'country': '1929'}]

def lire_dict(dict):
    for element in dict:
        print("{} est né.e en {}".format(element["name"],element["country"]))

lire_dico(exemple_dict)

7.5.2

def lire_dict_edu(dict):
    for element in dict:
        if element["email"].split(".")[-1] == 'edu':
            print("{} a pour email {}".format(element["name"],element["email"]))

read_dict_edu(example_dict)

7.6

def compte_lettres(phrase):
    dict={}
    # Pour chaque lettre:
    for lettre in phrase:
    # Si la clef existe (dans ce cas la lettre a déjà été rencontrée) alors on incremente sa valeur de 1.
        if lettre in dict:
            dict[lettre]+=1
    # Si la clef n'existe pas, on la crée et on initialise sa valeur à 1
        else:
            dict[lettre]=1
    return dict

phrase="Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt "
print(compte_lettres(phrase))

7.7

def retourne_pair(liste):
    nouvel_liste=[]
    for nombre in liste:
        if nombre%2==0:
            nouvel_liste.append(element)
    return nouvel_liste

liste_paire=range(11)
print(retourne_pair(liste_paire))

7.8 Cette algorithme de tri classique s’appelle le tri à bulle. Ce n’est pas le plus rapide, mais il est facilement compréhensible.

def tri_a_bulles(tableau):
    for i in range(len(tableau),0,-1):
        for j in range(i-1):
            if tableau[j+1]<tableau[j]:
                tableau[j+1], tableau[j]=tableau[j],tableau[j+1]
    return tableau

7.9 On utlise ici une imbrication de compréhension de lire:

matrice=[[i+j for i in range(5)] for j in range(4)]

7.10

def somme_2(liste):
    if liste:
        #Litéralement ma somme vaut le dernier élément plus la somme de tous les autres éléments moins le dernier
        return liste[-1]+somme_2(liste[:-1])
    else:
        return 0

7.11

def carre():
    i=1
    while True:
        i+=1
        yield i*i

for i in carre():
    if i>200
        break
    print (i)

10.1

def liste_users():
    with open("/etc/passwd","r") as file:
        read_file=file.readlines()
    for element in read_file:
        e=element.rstrip().split(':')
        if e[-1]=="/bin/bash":
            print(e[0])

liste_users()

10.2

def generer_email(prenom,nom):
        modele = """
Bonjour {prenom} !
Voici en pièce jointe les billets pour votre voyage en train vers {destination}.
""".format(prenom=prenom,destination=nom)
        with open("email_{}".format(prenom), "w") as f:
            f.write(modele)

generer_email("Sacha","Rennes")

10.3

def afficher_fichier_no_comment(file,char):
    with open(file) as file_read:
        read_file=file_read.readlines()
    print(read_file)
    for element in read_file:
        if not element.strip() == "" and not element[0]==char:
            print(element,end='')
afficher_fichier_no_comment("test","#")

Exercice 2.1 - Fichiers, JSON et dictionnaires

2.1 - Fichiers, JSON et dictionnaires

  • Écrire une fonction qui prends un nom de fichier en argument et retourne le contenu si elle a été capable de le récupérer. Sinon, elle doit déclencher une exception qui explique en français pourquoi elle n’a pas pu.

  • Écrire une fonction qui remplace un mot par un autre dans un fichier. On pourra pour cela se servir de une_chaine.replace("mot", "nouveau_mot") qui renvoie une version modifiée de une_chaine en ayant remplacé “mot” par “nouveau mot”.

  • Télécharger le fichier https://app.yunohost.org/community.json (avec votre navigateur ou wget par exemple). Écrire une fonction qui lit ce fichier, le charge en tant que données json et renvoie un dictionnaire Python. Écrire une autre fonction capable de filtrer le dictionnaire pour ne garder que les apps d’un level supérieur ou égal à un level n donné en argument. Essayez votre fonction avec le niveau 8.

  • Améliorez le programme précédent pour récupérer la liste directement depuis le programme avec requests. Gérer les différentes exceptions qui pourraient se produire (afficher un message en français) : syntaxe json incorrecte, erreur 404, time-out du serveur, erreur SSL

Exercice 2.2 - Utilisation de la librairie XML intégrée ElementTree

  • En utilisant le module ElementTree de Python, charger le fichier countries.xml fourni par le formateur. Boucler sur les différents éléments country et afficher pour chaque élément la valeur du gdppc (PIB par habitant) et le nom des voisins.

  • Ajouter un element country pour la France en suivant la même structure.

  • Sauvegarder la version modifiée en countries_extended.xml

Exercice 2.3 - Lecture itérative avec la library externe lxml

  • Installez lxml grâce à pip3, et récupérez le “gros” fichier XML, copyright.xml à l’adresse https://dl.google.com/rights/books/renewals/google-renewals-20080516.zip. Attention à ne pas tenter d’ouvrir “brutalement” ce fichier avec un éditeur ou avec la méthode utilisée en 1 : cela consommera beaucoup trop de RAM !

  • En utilisant des commandes comme head -n 50 copyright.xml, analyser visuellement la structure du fichier d’après ses premières lignes.

  • Initialiser un itérateur destiné à itérer sur ce fichier, et en particulier sur les tags Title. Créer une boucle à partir de cet itérateur et afficher tous les titres qui contiennent la chaîne "Pyth". On prendra soin de nettoyer les éléments trouvés avant de passer à chaque nouvelle itération sous peine de remplir la RAM très vite !

  • Pour chaque titre trouvé, remonter au parent ‘Record’ pour trouver le ‘Holder Name’ correspondant à ce titre. S’aider du debug VSCode, ipython et/ou ipdb pour tester et expérimenter en interactif.

Partie 3 - POO

Cours 3

13. POO - Classes, attributs et méthodes

L’orienté objet est un paradigme de programmation inventé dans les années 80 et popularisé dans les années 90. Aujourd’hui il est incontournable bien qu’il commence aussi à être critiqué.

Il permet d’organiser un programme de façon standard et ainsi d’éviter des erreurs d’architectures comme le spaghetti code

Principe de base

Regrouper les variables et fonctions en entités (“objets”) cohérentes qui appartiennent à des classes

  • attributs (les variables décrivant l’état de l’objet)
  • méthodes (les fonctions appliqubles à l’objet)

De cette façon on fabrique des sorte types de données spécifique à notre programme utilisables de façon pratique et consistante.

Exemple

Les cercles (classe)

ont un centre, un rayon, une couleur, une épaisseur de trait : ce sont des attributs.

On peut : déplacer le cercle, l’agrandir, calculer son aire, le dessiner sur l’écran : ce sont des méthodes.

Un petit cercle rouge (objet, ou instance)

centre = (3, 5), rayon = 2, couleur = “red”, épaisseur = 0.1

Un grand cercle bleu (autre objet, instance)

centre = (-4, 2), rayon = 6, couleur = “blue”, épaisseur = 1

Exemple en Python

class Cercle:

   def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
       self.centre = centre
       self.rayon = rayon
       self.couleur = couleur
       self.epaisseur = epaisseur

   def deplacer(self, dx=0, dy=0):
       self.centre = (self.centre[0]+dx, self.centre[1]+dy)


cercle1 = Cercle((3, 5), 2, "red")
cercle2 = Cercle((-4, 2), 6, "blue", epaisseur=1)

cercle1.deplacer(dy=2)
print(cercle1.centre)
  • __init__ est le constructeur C’est la fonction qui est appelée à la création de l’objet.

  • On instancie un objet en faissant mon_objet = Classe(...) ce qui appelle __init__

  • self correspond à l’objet en train d’être manipulé. Il doit être passé en paramètre de toutes les fonctions de la classe (les méthodes)

Les attributs sont les variables internes qui décrivent l’état et régisse le fonctionnement de l’objet.

  • self.centre, self.rayon, self.couleur, self.epaisseur sont ici les attributs. Si on lit littéralement la syntaxe python on comprend self.centre comme “le centre de l’objet en cours(le cercle en cours)”

Toutes les fonctions incluses dans la classe sont appelées des méthodes.

  • __init__ et deplacer sont des méthodes. Elles agissent généralement sur les attributs de l’objet mais pas nécessairement.

Les attributs et méthodes de la classe sont “dans” chaque instance d’objet (ici chaque cercle). On dit que la classe est un namespace (ou espace de nom). Chaque variable centre est isolée dans son cercle et on peut donc réutiliser plusieurs fois le nom centre pour chaque cercle. Par contre pour y accéder on doit préciser le cercle concerné avec la syntaxe cercle1.centre.

  • De même on utilise les methodes en faisant un_objet.la_methode(...)

Attention à l’indentation !!

Spaghetti code, variables globales et refactoring

Lorsqu’on enchaine simplement des instructions sans trop de structure dans un programme on arrive vite à quelque chose d’assez imprévisible et ingérable.

On commence généralement à définir des variables globales accessibles partout pour maintenir l’état de notre programme. Plusieurs fonctions viennent modifier de façon concurrente ces variables globales (pensez au score dans un jeu par exemple) pouvant mener à des bugs complexes.

On arrive aussi à beaucoup de code dupliqué et il devient très difficile dans ce contexte de refactorer un programme:

  • dès qu’on tire un spaghetti tout casse
  • dès qu’on veut changer un endroit il faut modifier beaucoup de choses
  • la compréhension du programme devient difficile pour le développeur initial et encore plus pour ses collègues.

On peut voir la programmation orientée objet comme une façon d’éviter le code spaghetti.

Intérets de la POO

La POO est critique pour garder un code structuré et compréhensible quand la complexité d’un projet augmente.

  • Rassembler ce qui va ensemble pour s’y retrouver
  • Maintenir les variables isolées à l’intérieur d’un “scope” pour évitées qu’elles ne soient modifiée n’importe quand et n’importe comment et qu’il y ai des conflits de nom.
  • Fournir une façon d’architecturer un programme que tout le monde connait à peu près
  • Fournir un moyen efficace de programmer en évitant la répétition et favorisant la réutilisation
  • Créer des “boîtes noires” utilisables sans connaître leur fonctionnement interne (bien et pas bien à la fois). C’est à dire une façon de se répartir le travail entre développeurs (chacun sa boîte qu’on maîtrise).

DRY don’t repeat yourself et couplage

La POO permet d’appliquer le principe DRY -> identifier ce qui se ressemble et le rassembler dans une méthode ou une classe.

Cela permet ensuite de modifier le code à un seul endroit pour tout changer -> puissant.

Il s’agit plus d’un ideal que d’un principe. Il ne faut pas l’appliquer à outrance parfois un peu de répétition est mieux car plus simple.

Si on factorise tout en POO on arrive souvent à un code fortement coupler qui empêche le refactoring et le programme finit par devenir fragile.

À retenir

  • __init__ est le constructeur
  • __init__ et deplacer sont des méthodes
  • self correspond à l’objet en train d’être manipulé
  • Toutes les méthodes ont au moins self comme premier argument
  • On utilise les methodes en faisant un_objet.la_methode(...)
  • self.centre, self.rayon, self.couleur, self.epaisseur sont des attributs
  • On instancie un objet en faissant mon_objet = Classe(...)

14. Héritage et polymorphisme

Héritage

Une classe peut hériter d’une autre pour étendre ses fonctionnalités. Inversement, cela permet de factoriser plusieurs classes ayant des fonctionnalités communes.

Par exemple, les cercles, les carrés et les étoiles sont trois types de figures géométriques.

En tant que figure géométriques, elles ont toutes un centre, une couleur et une épaisseur utilisés pour le dessin. On peut les déplacer, et on peut calculer leur aire.

  • L’héritage permet d’ordonner des objets proches en les apparentant pour s’y retrouver.
  • Il permet également de factoriser du code en repérant des comportements génériques utilisés dans plusieurs contextes et en les mettant dans un parent commun.
class FigureGeometrique:

    def __init__(self, centre, couleur="black", epaisseur=0.1):
        raise NotImplementedError("La classe fille doit implémenter cette fonction!")
        self.centre = centre
        self.couleur = couleur
        self.epaisseur = epaisseur

    def deplacer(self, dx=0, dy=0):
        self.centre = (self.centre[0]+dx, self.centre[1]+dy)

    def aire(self):
        raise NotImplementedError("La classe fille doit implémenter cette fonction!")

class Cercle(FigureGeometrique):

    def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
        self.rayon = rayon
        super().__init__(centre, couleur, epaisseur)

    def aire(self):
        return 3.1415 * self.rayon * self.rayon

class Carre(FigureGeometrique):

    def __init__(self, centre, cote, couleur="black", epaisseur=0.1):
        self.cote = cote
        super().__init__(centre, couleur, epaisseur)

    def aire(self):
        return self.cote ** 2


cercle_rouge = Cercle((3, 5), 2, "red")
carre_vert  = Carre((5, -1), 3, "green", epaisseur=0.2)

cercle_rouge.deplacer(dy=2)
carre_vert.deplacer(dx=-3)

print(carre_vert.centre) # -> affiche (2, -1)
print(carre_vert.aire()) # -> affiche 9
  • Les cercles et les carrés “descendent” ou “héritent” de la classe FigureGeometrique avec la syntaxe class Carre(FigureGeometrique).

  • La méthode deplacer de la classe mère est disponible automatiquement dans les classes filles

Ainsi pour factoriser du code on peut repèrer un comportement commun à plusieurs éléments de notre programme et on créé une classe mère avec une méthode exprimant ce comportement de façon générique. Tous les classes fille pourront utiliser ce comportement. Si on le change plus tard il sera changé dans tout le programme (puissant pour refactoriser le code)

Cependant il est rare qu’un comportement soit exactement identique entre deux classes. On veut souvent changer légèrement ce comportement selon la classe utilisée. Pour cela on utilise le polymorphisme.

Polymorphisme

Surcharge de fonction

Dans le cas de l’aire de nos figures, chaque figure doit pouvoir calculer son aire mais le calcul est différent pour chaque type de figure concrête.

  • On définit une méthode abstraite aire dans la classe mère pour indiquer que chaque figure a une méthode aire. Comme une figure en général n’a pas de calcul d’aire la méthode abstraite déclenche une exception (Utilisez ici NotImplementedError() qui est faite pour ça)

  • On redéfinit la méthode aire dans chaque classe fille. La méthode aire fille écrase ou surcharge celle de la classe mère et sera appelée à la place de celle-ci dès qu’on veut l’aire d’une figure géométrique.

Découper le travail en méthode mère et fille avec super().methode()

Souvent on veut quand même utiliser la méthode de la classe même pour faire une partie du travail (commun à toute les classes filles) et ensuite spécialiser le travail en ajoutant des actions suplémentaires dans la méthode fille qui surcharge la méthode mère. A cause de la surcharge la méthode mère n’est pas du tout appelée automatiquement donc il faut le faire “manuellement”.

Exemple ci-dessus: pour créer un carré:

  • on appelle d’abord le constructeur de la classe mère qui initialise centre, couleur et epaisseur avec super().__init__()
  • Puis on initialise cote qui est un attribut du carré (mais pas du cercle donc pas dans le constructeur général)

De façon générale super() renvoie une instance de la classe mère.

Classe Abstraite

Une classe abstraite est une classe dont on ne peut pas créer d’instance. Elle est simplement là pour définir un modèle minimal que toutes les classes fille doivent suivre (et étendre).

En Python on créé généralement une classe abstraite en levant l’exception NotImplementedError dans le constructeur __init__.

Travailler avec la classe mère

On parle de polymorphisme quand on utilise la classe abstraite pour gérer uniformément plusieurs type d’objets de classe différente et qu’on laisse le langage choisir le comportement en fonction du contexte.

Par exemple on peut faire une liste de FigureGeometrique de différents types et afficher les aire de chacune. Python devinera automatiquement quelle méthode appeler :

formes = [Cercle((3, 5), 2, "red"),
          Carre((5, -1), 3, "green"),
          Cercle((-2, 4), 5, "yellow"),
          Carre((4, -2), 2, "purple")]

for forme in formes:
    print(forme.aire())

(c.f. aussi autre exemple sur stack overflow)

Le polymorphisme est puissant car il permet d’économiser beaucoup de if et autre branchements:

On aurait pu écrire l’exemple précédent avec des if isinstance(figure, Cercle): par exemple mais cela aurait été beaucoup moins élégant.

À retenir

  • class Cercle(FigureGeometrique) fais hériter Cercle de FigureGeometrique
  • super().__init__(...) permet d’appeler le constructeur de la classe mère
  • Les classes filles disposent des méthodes de la classe mère mais peuvent les surcharger (c.f. exemple avec aire)
  • super().une_methode(...) permet d’appeler une_methode telle que définie dans la classe mère.
  • isinstance verifie l’heritage ! isinstance(cercle_rouge, FigureGeometrique) vaut True !

Tester la classe pour s’adapter

Souvent pour adapter le comportement d’un programme on veut savoir de quel type est un objet:

  • isinstance verifie l’heritage ! isinstance(cercle_rouge, FigureGeometrique) vaut True !

15. Encapsulation et attributs statiques

D’abord quelques astuces

  • dir(un_objet) : listes tous les attributs / methodes d’un objet (ou module)
  • Il existe aussi un_objet.__dict__
  • MaClasse.__subclasses__() : lister toutes les classes filles d’une classe

Attributs ‘statiques’ (partagés par tous les objets d’une classe)

Les attributs qui sont définits dans le corps de la classe et non dans le constructeurs sont statiques en python. C’est à dire que leur valeur est commune à toutes les instances de la classe en cours d’utilisation dans le programme. Cela peut être très pratique pour maintenir une vision globale de l’état du programme de façon sécurisée.

class FormeGeometrique():

    nb_instances = 0

    def __init__(self):
        FormeGeometrique.nb_instances += 1

forme1 = FormeGeometrique()
forme2 = FormeGeometrique()
forme3 = FormeGeometrique()

print(FormeGeometrique.nb_instances)
# -> affiche 3

Méthodes statiques et méthodes de classe

… Sont deux types de méthodes rattachées à une classe mais non à une instance de la classe (un objet). On les fabrique en ajoutant les décorateurs @staticmethod ou @classmethod sur une méthode de la classe.

La méthode statique est complètement indépendante de la classe même si rangée à l’intérieur alors que la méthode de classe récupère implicitement sa classe comme premier argument ce qui permet de construire des objet de la classe dans le corps de la méthode

Exemple d’utilisation d’un méthode de classe

class MaCollectionDeLettre: # Réimplétation de String

    def __init__(self, astring): # Build an object from a string
      self._string = astring

    @classmethod
    def build_from_list(cls, alist): # Alternative constructor to build from a list of lettres
      x = cls('') # L'argument implicite cls permet de construire un objet de la classe
      x._string = ','.join(str(s) for s in alist)
      return x

L’encapsulation

Nous avons évoqué dans le cours 13 qu’un des intérêts de la POO est de sécuriser les variables dans un contexte isolé pour éviter qu’elles soient accédées à tort et à travers par différents programmeurs ce qui a tendance à créer des bugs mythiques.

Pour éviter cela on essaye au maximum d’encapsuler les attributs et les méthodes internes qui servent à faire fonctionner une classe pour éviter que les utilisateurs de la classe (ignorants son fonctionnement) puissent pas les appeler directement et “casser” le fonctionnement de la classe.

On parle d’attributs et méthodes privés quand ils sont internes et inaccessibles.

En Python les attributs et méthodes d’un objet sont “publiques” par défaut : on peut y accéder quand on veut et donc il faut donc une façon de pouvoir interdire leur usage:

  • On utilise un underscore _ devant le nom de l’attribut ou méthode pout indiquer qu’il est privé et ne doit pas être utilisé.

Exemple: self._valeurinterne = 50 ou def _mamethodeprivee(self, arg): ...

En réalité l’attribut/méthode est toujours accessible, il s’agit d’une convention mais il faut la respecter !! Par défaut les editeurs de code vous masqueront les elements privés lors de l’autocomplétion par exemple.

Accesseurs (getters) et mutateurs (setters)

Même lorsque qu’un attribut d’objet devrait être accessible à l’utilisateur (par exemple le rayon d’un cercle), on voudrait pouvoir contrôler l’accès à cet attribut pour que tout ce passe bien.

Par exemple éviter que l’utilisateur puisse définir un rayon négatif !!

Pour cela on créé des attributs privés et on définit des méthodes “publique”

On veut donc généralement pouvoir y donner accès à l’utilisateur de la classe selon certaines conditions.

Pour cela un définit une méthode d’accès (getter/accesseur) qui décrit comment récupérer la valeur ou une méthode de modification (setter/mutateur) qui contrôle comment on peut modifier la valeur (et qui vous envoie balader si vous définissez un rayon négatif).

Exemple (non pythonique !)

class Cercle:

   def __init__(self, centre, rayon, couleur="black", epaisseur=0.1):
       self.centre = centre
       self._rayon = rayon
       self._couleur = couleur

    def get_couleur(self):
        print("on accède à la couleur")
        return self._couleur

    def set_rayon(self, rayon)
        assert rayon > 0, "Le rayon doit être supérieur à 0 !"
        self._rayon = rayon



cercle1 = Cercle((3, 5), 2, "red")
cercle1.get_couleur()
cercle1.set_rayon(1)
cercle1.set_rayon(-1) # Erreur

Cependant en Python on ne fait généralement pas directement comme dans cet exemple !

Des attributs “dynamiques” avec @property

Le décorateur @property ajouté à une méthode permet de l’appeler comme un attribut (sans parenthèses)

class Carre(FigureGeometrique):

    # [ ... ]

    @property
    def aire(self):
        return self.cote * self.cote


carre_vert  = Carre((5, -1), 3, "green", epaisseur=0.2)
print(carre_vert.aire) # N.B. : plus besoin de mettre de parenthèse ! Se comporte comme un attribut

Autre exemple avec @property

class Facture():

    def __init__(self, total):
        self.montant_total = total
        self.montant_deja_paye = 0

    @property
    def montant_restant_a_payer(self):
        return montant_total - montant_deja_paye


ma_facture = Facture(45)
ma_facture.montant_deja_paye += 7

print("Il reste %s à payer" % ma_facture.montant_restant_a_payer)
# -> Il reste 38 à payer

La façon pythonique de faire des getters et setters en python est donc la suivante:

        @property
        def toto(self):
            return self.__toto

        @toto.setter
        def toto(self, value):
            self.__toto = value   # ... ou tout autre traitement

On peut ensuite accéder et modifier l’attribut toto de manière transparente :

monobjet = Objet()

monobjet.toto = "nouvelle_valeur"
print(monobjet.toto)

16. Stockage de données et ORM

Enregistrer des objets avec pickle

pickle permet de “sérialiser” et “déserialiser” des objets (ou de manière générale des structure de données) en un flux binaire (!= texte).

Sauvegarde

import pickle

ma_facture = Facture(45)

f = open("save.bin", "wb")   # the 'b' in 'wb' is important !
pickle.dump(ma_facture, f)

Puis recuperation

import pickle

f = open("save.bin", "rb")
ma_facture = pickle.load(f)

Un exemple courant de POO : les ORM (Object Relationnal Mapper)

Rappels (?) sur SQL

  • Base de données : stocker des informations en masse et de manière efficace
  • On manipule des tables (des lignes, des colonnes) …
  • Les colonnes sont fortement typées et on peut poser des contraintes (unicité, …)
  • Relations entres les tables, écritures concurrentes, …
  • Exemple de requête :
# Create a table
CREATE TABLE members (username text, email text, memberSince date, balance real)

# Add a record
INSERT INTO members VALUES ('alice', 'alice@gmail.com', '2017-11-05', 35.14)

# Find records
SELECT * FROM members WHERE balance>0;

Orienté objet : ORM

SQL “brut” en Python

import sqlite3
conn = sqlite3.connect('example.db')

c = conn.cursor()

# Create a table
c.execute('''CREATE TABLE members
             (username text, email text, memberSince date, balance real)''')

# Add a record
c.execute("INSERT INTO members VALUES ('alice', 'alice@gmail.com', '2017-11-05', 35.14)")

# Save (commit) the changes and close the connection
conn.commit()
conn.close()

Définition - Object Relational Mapping

  • Sauvegarder et charger des objets dans une base de donnée de type SQL de manière “transparente”
  • Simplifie énormément l’interface entre Python et SQL
    • Python <-> base SQL
    • classes (ou modèle) <-> tables
    • objets <-> lignes
    • attributs <-> colonnes
  • Gère aussi la construction et execution des requêtes (query)
  • Syntaxe spéciale pour définir les types et les contraintes (en fonction de la lib utilisée)
  • Librairie populaire et efficace : SQLAlchemy (on utilisera la surcouche ActiveAlchemy)

Exemple de classe / modèle

from active_alchemy import ActiveAlchemy

db = ActiveAlchemy('sqlite:///members.db')

class Member(db.Model):
	username    = db.Column(db.String(25), nullable=False, unique=True)
	email       = db.Column(db.String(50), nullable=True)
	memberSince = db.Column(db.Date,       nullable=False)
    balance     = db.Column(db.Float,      nullable=False, default=0.0)
    active      = db.Column(db.Boolean,    nullable=False, default=True)

Créer des tables et des objets

# Supprimer toutes les tables (attention ! dans la vraie vie on fait des migrations...)
db.drop_all()
# Initialiser toutes les tables dont il y a besoin
db.create_all()

# Créer des utilisateurs
alice   = Member(name="Alice",   memberSince=datetime.date(day=5, month=11, year=2017))
bob     = Member(name="Bob",     memberSince=datetime.date.today(), balance=15)
camille = Member(name="Camille", memberSince=datetime.date(day=7, month=10, year=2018), balance=10)

# Dire qu'on veut les enregistrer
db.session.add(alice)
db.session.add(bob)
db.session.add(camille)

# Commiter les changements
db.session.commit()

Exemple de requete (query)

all_members = Member.query().all()

active_members = Member.query()
                .filter(Member.active == True)
                .order_by(Member.memberSince)

for member in active_members:
    print(user.name)

Exercices Partie 3

Correction 3.1 - Cercles et Cylindres

Dans cet exercice nous allons représenter des objets et calculs géométriques simples en coordonnées entières. Utilisez des annotations de types : int, -> None, -> int et : Tuples[int ...] dès que possible. Testez régulièrement la consistance de ces types avec mypy fichier.py.

  • Implémenter une classe Cercle avec comme attributs un rayon rayon et les coordonnées x et y de son centre. Par exemple on pourra instancier un cercle avec mon_cercle = Cercle(5, (3,1))

  • Dans la classe Cercle, implémenter une propriété aire dépendante du rayon qu’on peut appeler avec mon_cercle.aire.

  • Implémenter une classe Cylindre, fille de Cercle, qui est caractérisée par un rayon rayon, une hauteur hauteur et des coordonnées x, y et z. On écrira le constructeur de Cylindre en appelant le constructeur de Cercle.

  • Dans la classe Cercle, implémenter une méthode intersect qui retourne True ou False suivant si deux cercles se touchent. Exemple d’utilisation : c1.intersect(c2)

  • Surcharger la méthode intersect pour la classe Cylindre, en se basant sur le résultat de la méthode de la classe mère.

Correction

Correction 3.1

Correction exercice 3.2 - Jeu de carte

Une classe Carte pour représenter les éléments d’un jeu

  • Dans un fichier carte.py, créer une classe Carte. Une carte dispose d’une valeur (1 à 10 puis VALET, DAME et ROI) et d’une couleur (COEUR, PIQUE, CARREAU, TREFLE). Par exemple, on pourra créer des cartes en invoquant Carte(3, 'COEUR') et Carte('ROI', 'PIQUE').

  • Implémenter la méthode points pour la classe Carte, qui retourne un nombre entre 1 et 13 en fonction de la valeur de la carte. Valider ce comportement depuis un fichier main.py qui importe la classe Carte.

  • Implémenter la méthode __repr__ pour la classe Carte, de sorte à ce que print(Carte(3, "COEUR")) affiche <Carte 3 de COEUR>.

c = Carte("DAME", "PIQUE")

print(c.couleur)
# Affiche PIQUE

print(c.points)
# Affiche 12

print(c)
# Affiche <Carte DAME de PIQUE>
Correction 3.2 `carte.py`

Encapsulation et validation des valeurs de carte possibles

Pour sécuriser l’usage ultérieur de notre jeu de carte on aimerait que les cartes ne puissent être crées et modifiées qu’avec des valeurs correctes (les 4 couleurs et 13 valeurs précisées)

  • Modifiez le constructeur pour valider que les données fournies sont valides. Sinon levez une exception (on utilise conventionnellement le type d’exception ValueError pour cela ou un type d’exception personnalisé).

  • Modifiez également les paramètres couleur et valeur pour les rendre privés, puis créer des accesseurs et mutateurs qui permettent d’y accéder en mode public et de valider les données à la modification.

Correction 3.2 `carte.py`

La classe Paquet, une collection de cartes

  • Dans un nouveau fichier paquet.py, créer une classe Paquet correspondant à un paquet de 52 cartes. Le constructeur devra créer toute les cartes du jeu et les stocker dans une liste ordonnée. Vous aurez probablement besoin d’importer la classe Carte. Testez le comportement de cette classe en l’important et en l’utilisant dans main.py.

  • Implémenter la méthode melanger pour la classe Paquet qui mélange l’ordre des cartes.

  • Implémenter la méthode couper qui prends un nombre aléatoire du dessus du paquet et les place en dessous.

  • Implémenter la méthode piocher qui retourne la Carte du dessus du paquet (eticla l’enlève du paquet)

1.0 : Implémenter la méthode distribuer qui prends en argument un nombre de carte et un nombre de joueurs (e.g. p.distribuer(joueurs=4, cartes=5)), pioche des cartes pour chacun des joueurs à tour de rôle, et retourne les mains correspondantes.

p = Paquet()
p.melanger()

main_alice, main_bob = p.distribuer(joueurs=2, cartes=3)

print(main_alice)
# affiche par exemple [<Carte 3 de PIQUE>, <Carte VALET de CARREAU>, <Carte 1 de trefle>]

print(p.pioche())
# affiche <Carte 9 de CARREAU>

print(main_alice[1].points())
# affiche 11
Correction 3.2 `paquet.py`
Correction 3.2 `main.py`

Correction exercice 3.3 - Introduction aux ORM avec ActiveAlchemy

On se propose de reprendre le jeu de données des apps Yunohost (Exos part 2, fichier app.yunohost.org/community.json) et d’importer ces données dans une base SQL (plus précisémment SQLite)

  • Installer active_alchemy à l’aide de pip3

  • Créer un fichier mydb.py qui se contente de créer une base db (instance de ActiveAlchemy) de type sqlite. Dans la suite, on importera l’objet db depuis mydb.py dans les autres fichiers si besoin.

  • Créer un fichier models.py et créer dedans une classe (aussi appellé modèle) App. On se limitera aux attributs (aussi appellés champs / colonnes) suivants :

    • un nom qui est une chaîne de caractère unique parmis toutes les App ;
    • un niveau qui est un entier (ou vide) ;
    • une adresse qui est une chaîne de caractère unique parmis toutes les App ;
  • Créer un fichier nuke_and_reinit.py dont le rôle est de détruire et réinitialiser les tables, puis de les remplir avec les données du fichier json. On utilisera pour ce faire db.drop_all() et db.create_all(). Puis, itérer sur les données du fichier json pour créer les objets App correspondant. Commiter les changements à l’aide de db.session.add et commit.

  • Créer un fichier analyze.py qui cherche et affiche le nom de toutes les App connue avec un niveau supérieur ou égal à n. En utilisant l’utilitaire bash time (ou bien avec time.time() en python), comparer les performances de analyze.py avec un script python équivalent mais qui travaille à partir du fichier community.json directement (en local, pas via requests.get)

mydb.py

from active_alchemy import ActiveAlchemy

db = ActiveAlchemy('sqlite:///apps.db')

models.py

from mydb import db

class App(db.Model):
    name = db.Column(db.String(20), unique=True, nullable=False)
    level = db.Column(db.Integer, nullable=True)
    url = db.Column(db.String(50), unique=True, nullable=False)
    
    def __repr__(self):
        return "<App " + self.name + ">"

nuke_and_reinit

import json
from mydb import db
from models import App

db.drop_all()
db.create_all()

with open("apps.json") as f:
    apps_from_json = json.loads(f.read())

for app, infos in apps_from_json.items():
    a = App(name=app, level=infos["level"], url=infos["git"]["url"])
    db.session.add(a)

db.session.commit()

apps_level_3 = App.query().filter(App.level == 3)
for app in apps_level_3:
    print(app.name)

Exercice 3.1 - Cercles et Cylindres

Dans cet exercice nous allons représenter des objets et calculs géométriques simples en coordonnées entières. Testez régulièrement la consistance de ces types avec mypy fichier.py.

  • Implémenter une classe Cercle avec comme attributs un rayon rayon et les coordonnées x et y de son centre. Par exemple on pourra instancier un cercle avec mon_cercle = Cercle(5, (3,1))

  • Dans la classe Cercle, implémenter une propriété aire dépendante du rayon qu’on peut appeler avec mon_cercle.aire.

  • Implémenter une classe Cylindre, fille de Cercle, qui est caractérisée par un rayon rayon, une hauteur hauteur et des coordonnées x, y et z. On écrira le constructeur de Cylindre en appelant le constructeur de Cercle.

  • Surcharger la méthode aire pour la classe Cylindre, en se basant sur le résultat de la méthode de la classe mère.

Exercice 3.2 - Jeu de carte

Une classe Carte pour représenter les éléments d’un jeu

  • Dans un fichier carte.py, créer une classe Carte. Une carte dispose d’une valeur (1 à 10 puis VALET, DAME et ROI) et d’une couleur (COEUR, PIQUE, CARREAU, TREFLE). Par exemple, on pourra créer des cartes en invoquant Carte(3, 'COEUR') et Carte('ROI', 'PIQUE').

  • Implémenter la méthode points pour la classe Carte, qui retourne un nombre entre 1 et 13 en fonction de la valeur de la carte. Valider ce comportement depuis un fichier main.py qui importe la classe Carte.

  • Implémenter la méthode __repr__ pour la classe Carte, de sorte à ce que print(Carte(3, "COEUR")) affiche <Carte 3 de COEUR>.

c = Carte("DAME", "PIQUE")

print(c.couleur)
# Affiche PIQUE

print(c.points)
# Affiche 12

print(c)
# Affiche <Carte DAME de PIQUE>

Encapsulation et validation des valeurs de carte possibles

Pour sécuriser l’usage ultérieur de notre jeu de carte on aimerait que les cartes ne puissent être crées et modifiées qu’avec des valeurs correctes (les 4 couleurs et 13 valeurs précisées)

  • Modifiez le constructeur pour valider que les données fournies sont valides. Sinon levez une exception (on utilise conventionnellement le type d’exception ValueError pour cela ou un type d’exception personnalisé).

  • Modifiez également les paramètres couleur et valeur pour les rendre privés, puis créer des accesseurs et mutateurs qui permettent d’y accéder en mode public et de valider les données à la modification.

La classe Paquet, une collection de cartes

  • Dans un nouveau fichier paquet.py, créer une classe Paquet correspondant à un paquet de 52 cartes. Le constructeur devra créer toute les cartes du jeu et les stocker dans une liste ordonnée. Vous aurez probablement besoin d’importer la classe Carte. Testez le comportement de cette classe en l’important et en l’utilisant dans main.py.

  • Implémenter la méthode melanger pour la classe Paquet qui mélange l’ordre des cartes.

  • Implémenter la méthode couper qui prends un nombre aléatoire du dessus du paquet et les place en dessous.

  • Implémenter la méthode piocher qui retourne la Carte du dessus du paquet (et l’enlève du paquet)

1.0 : Implémenter la méthode distribuer qui prends en argument un nombre de carte et un nombre de joueurs (e.g. p.distribuer(joueurs=4, cartes=5)), pioche des cartes pour chacun des joueurs à tour de rôle, et retourne les mains correspondantes.

Exercice 3.3 - Introduction aux ORM avec ActiveAlchemy

On se propose de reprendre le jeu de données des apps Yunohost (Exos part 2, fichier app.yunohost.org/community.json) et d’importer ces données dans une base SQL (plus précisémment SQLite)

  • Installer active_alchemy à l’aide de pip3

  • Créer un fichier mydb.py qui se contente de créer une base db (instance de ActiveAlchemy) de type sqlite. Dans la suite, on importera l’objet db depuis mydb.py dans les autres fichiers si besoin.

  • Créer un fichier models.py et créer dedans une classe (aussi appellé modèle) App. On se limitera aux attributs (aussi appellés champs / colonnes) suivants :

    • un nom qui est une chaîne de caractère unique parmis toutes les App ;
    • un niveau qui est un entier (ou vide) ;
    • une adresse qui est une chaîne de caractère unique parmis toutes les App ;
  • Créer un fichier nuke_and_reinit.py dont le rôle est de détruire et réinitialiser les tables, puis de les remplir avec les données du fichier json. On utilisera pour ce faire db.drop_all() et db.create_all(). Puis, itérer sur les données du fichier json pour créer les objets App correspondant. Commiter les changements à l’aide de db.session.add et commit.

  • Créer un fichier analyze.py qui cherche et affiche le nom de toutes les App connue avec un niveau supérieur ou égal à n. En utilisant l’utilitaire bash time (ou bien avec time.time() en python), comparer les performances de analyze.py avec un script python équivalent mais qui travaille à partir du fichier community.json directement (en local, pas via requests.get)

Partie 4 - Python Object Model et modules

Cours 4

17. Python Object Model et sujets avancés

Python Object Model

Si on regarde un autre langage orienté objet avant Python il paraît étrange de mettre len(collection) au lieu de collection.len() (faire comme s’il s’agissait d’un fonction plutôt que d’une méthode). Cette apparente bizarrerie est la partie émergée d’un iceberg qui, lorsqu’il est bien compris, est la clé de ce qui est pythonique. L’iceberg est appelé le Python Object(ou Data) Model, et il décrit l’API que vous pouvez utiliser pour faire jouer vos propres objets avec les constructions idiomatiques du langage Python. (traduction d’un paragraphe du livre Fluent Python)

Cette API (application programming interface = série de fonctions qui décrivent ce qu’on peut faire) se compose d’attributs et méthodes “spéciales” qui sont encadrées par des doubles underscores (__ ) comme __add__.

Exemple 1: redéfinir l’addition avec __add__

On peut créer une méthode def __add__(self, autre_objet_de_la_classe): ... pour dans nos classe pour redéfinir le symbole + appliqué à nos objets.

Exemple un vecteur 2D:

class Vector2d:
    typecode = 'd'

    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)

    def __add__(self, autre_vecteur):
        return Vector2d(self.x + autre_vecteur.x, self.y + autre_vecteur.y)

nouveau_vecteur = Vector2d(3, 4) + Vector2d(3, 7) # -> Vector2d(6, 11)

On parle aussi dans ce cas de surcharge d’opérateur qui est un classique dans les langage de POO.

Exemple 2: faire de notre objet un conteneur pythonique avec __setitem__ et __getitem__

class MaCollectionEnnuyeuse:
    def __init__(self, collection):
        self.mesitems = list(collection)

    def __getitem__(self, indice):
        return self.mesitems[indice] 

    def __setitem__(self, indice, item_a_ajouter):
        return self.mesitems[indice] = item_a_ajouter

print(MaCollectionEnnuyeuse("Hello")[0:1]) # -> Renvoie 'He'

Une fois qu’on a implémenté le minimum de l’interface on peut utiliser des fonctions python intégrées par exemple ici on peut faire directement

shuffle(MaCollectionEnnuyeuse('Diantre')) # -> Mélange les lettres de Diantre 

En fait, on peut dire qu’être une liste en python c’est plus ou moins avoir les méthodes spéciales qui définissent la liste. Pareil pour le dictionnaire. Un bon exemple de ce principe est l’itérable : tout objet qui peut renvoyer un iterateur avec __iter__ est utilisable dans une boucle for (puissant)

Exemple3 : les iterateurs

En python pour pouvoir utiliser la puissance de la boucle for on a besoin d’un objet itérateur ou d’un objet itérable c’est à dire un objet dont on peut tirer automatiquement un itérateur.

Une liste est itérable, ce qui veut dire qu’elle possède une fonction __iter__ qui renvoie un itérateur sur ses éléments.

Un itérateur est un objet qui:

  • possède une méthode __next__ qui renvoie l’élément suivant de l’itération
  • possède une méthode __iter__ qui renvoie un objet itérateur avec lequel continuer l’itération (souvent un simple return self)
  • déclenche une exception de type StopIteration lorsqu’il n’y a plus d’élément à itérer

Méthodes spéciales

Il existe plein de méthodes spéciales pour implémenter toutes les syntaxes, comportements sympathiques, et fonctions de base incluses dans Python (comme shuffle ou sort). Quelques autre:

  • __repr__ et __str__ : génère automatiquement une représentation de l’objet sous forme de chaîne de caractères (la première est une représentation basique pour le debug, la deuxième prioritaire est pour une représentation plus élégante de l’objet) qui permet de faire un “joli” print(mon_objet)
   def __str__(self):
      return "Cercle de couleur " + self.color + " et de rayon " + self.rayon
  • __eq__ : définir l’égalité entre deux objets. Très important pour faire des comparaison rapide et par exemple permettre de trier automatiquement vos objets dans une liste. Etc

  • __bool__: Permet de convertir votre objet en booléen et ainsi de supporter des syntaxes comme

if mon_objet:
    print("c'est bon")
else:
    print("c'est pas bon")

ETC…

Cf. le livre Fluent Python et la doc officielle

Implémenter ces différentes fonctions d’API n’est pas obligation mais surtout utile pour construire du code (souvent de librairie) qui sera agréable à utiliser pour les autre développeurs habitués à Python.

Design Patterns

En fait au delà de Python et de la POO, lorsqu’on construit des programmes on peut identifier des bonnes façon de résoudre des problèmes courants ou qui on une forme courante qu’on retrouve souvent dans les programmes. On appelle ces méthodes/forme des Design Patterns.

Par exemple l’iterateur (Pattern Iterator) est un design pattern que le langage Python implémente à sa façon et qui propose une solution pratique au parcours d’une collection d’objets.

Le Decorator est également un motif pour personnaliser le fonctionnement d’une fonction ou classe sans la modifier (et donc sans complexifier le code principal) il est implémenté en python grace à une syntaxe spécifique du langage très utilisée (Cf juste après).

Ces “motifs de conception” logicielle proviennent d’un ouvrage éponyme, influent dans les années 90, du Gang of Four (Gof). En réalité c’est même plus général que ce livre orienté POO car on peut identifier des Design Patterns dans des langages très différents par exemple fonctionnels.

Il existe pas mal d’autres Patterns non implémentés direactement dans le langage Python:

Décorateurs

Les décorateurs sont en Python des sortes d'“emballages” qu’on ajoute aux fonctions et au classes pour personnaliser leur comportement sans modifier le code principal de la fonction. Concrètement les décorateurs sont des

En gros ça permet d’ajouter des prétraitements, des posttraitements et de modifier le comportement de la fonction elle

Programmes asynchrones en Python

Très bonne synthèse pour python >= 3.8 : https://www.integralist.co.uk/posts/python-asyncio/

Une synthèse de la synthèse (Perte d’information ;)) :

Un programme synchrone est un programme ou toutes les étapes de calculs sont éxecutées les unes à la suite des autres. Conséquence on attend la fin de chaque opération avant de continuer et si une opération prend du temps l’utilisateur attend.

Un programme asynchrone est un programme qui execute diférentes étapes de calcul sans respecter l’ordre linéraire du programme. Par exemple deux fonctions appelées en même temps et qui vont s’exécuter de façon concurrent (on les lance toutes les deux en même temps et elles se partagent les ressources de calculs).

Pour executer des morceaux de calculs de façon concurrente il y a pas mal d’approches dont:

  1. le multiprocessing : on lance plusieurs processus au niveau de l’os, un peu l’équivalent de plusieurs programme en parallèle. Ils peuvent se répartir les multiples processeurs d’une machine ou d’un cluster. C’est intéressant pour les gros calcul mais pour faire plein de petites taches c’est pas très intéressant car le changement de process prend du temps.

  2. le multithreading : on lance un processus système avec plusieurs processus “virtuels” “légers” à l’intérieur. Les différents threads peuvent aussi potentiellement utiliser plusieurs processeurs en même temps. Cependant le multithread est peu efficace en python (avec Cpython) à cause du Global Interpreter Lock. On utilise peu les threads.

  3. execution asynchrone dans un seul processus (asyncio basé sur une event loop): En gros les différents morceaux du code concurrents ne s’exécutent pas “réellement” en même temps, ils se partagent le temps d’exécution d’un seul processus de calcul en se passant la main. Cette approche n’utilise pas tous les processeurs disponibles mais est légère et facilement controlable.

Pourquoi un programme est-il lent ?

Avant de choisir une solution il faut étudier son programme pour diagnostiquer le ralentissement.

  • Très couramment à cause de blocages au niveau des entrées/sortie (IO) lorsqu’on attend qu’un serveur (sur le réseau ou autre) ou un device (le disque ou autre) réponde à une demande.
  • Parce que le calcul est très lourd et demande plein d’opérations processeur (CPU intensive) (courant mais plus rare dans les programmes réels)

Dans le premier cas il faut utiliser l’execution asynchrone (solution 3.) en coroutine (fonction commençant par async def) avec asyncio.

Dans le deuxième cas il faut utiliser le multiprocessing (solution 1.) pour maximiser les processeurs utilisés avec concurrent.futures.

On peut combiner facilement les deux approches si nécessaire.

Concrètement avec des exemples

On commence par essayer d’accélérer son programme avec asyncio

Exemple de asyncio:

import asyncio

async def foo():
    print("Foo!")

async def hello_world():
    await foo()  # waits for `foo()` to complete
    print("Hello World!")

asyncio.run(hello_world())

Il faut s’habituer à cette façon de programmer :

  • se rappeler qu’une fonction async def peut se réveille périodiquement pour s’exécuter (le flux d’exécution est plus dur à imaginer)
  • Il faut aussi gérer la concurrence entre les coroutines (attendre un résultat dont on a besoin pour continuer le calcul d’une autre coroutine avec await par exemple)

Exemple2 avec gather pour attendre et rassembler les résultat de plusieurs taches:

gather

import asyncio


async def foo(n):
    await asyncio.sleep(5)  # wait 5s before continuing
    print(f"n: {n}!")


async def main():
    tasks = [foo(1), foo(2), foo(3)]
    await asyncio.gather(*tasks)


asyncio.run(main())

Enfin pour compléter l’approche asyncio avec du multiprocessing (au cas ou c’est le processeur qui bloque et que le programme est toujours lent) on peut utiliser concurrent.futures et un Pool de Process (ProcessPoolExecutor).

Exemple de la doc Python ou on combine asyncio et concurrent.futures.

import asyncio
import concurrent.futures


def blocking_io():
    # File operations (such as logging) can block the
    # event loop: run them in a thread pool.
    with open("/dev/urandom", "rb") as f:
        return f.read(100)


def cpu_bound():
    # CPU-bound operations will block the event loop:
    # in general it is preferable to run them in a
    # process pool.
    return sum(i * i for i in range(10 ** 7))


async def main():
    loop = asyncio.get_running_loop()

    # 1. Run in the default loop's executor:
    result = await loop.run_in_executor(None, blocking_io)
    print("default thread pool", result)

    # 2. Run in a custom thread pool:
    with concurrent.futures.ThreadPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, blocking_io)
        print("custom thread pool", result)

    # 3. Run in a custom process pool:
    with concurrent.futures.ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, cpu_bound)
        print("custom process pool", result)


asyncio.run(main())

19. Organiser son code en modules, packages et librairies

Modules Python

Les modules Python sont le plus haut niveau d’organisation du code (plus que les classes).

Ils servent à regrouper des ensembles de classes et fonctions apparentées.

Un module est ce qu’on importe grace à import ou from ... import ....

Un module peut être un simple fichier

Si on met des fichiers python dans le même dossier ils constituent automatiquement des modules.

fichier mon_module.py:


ma_variable = 1

def ma_fonction(arg: int):
    return ma_variable + arg

fichier mon_module2.py:

from mon_module import ma_fonction

ma_variable = 2

fichier mon_programme_principal.py

import mon_module
import mon_module2


if __name__ == "__main__"
    ma_variable = 3
    print(mon_module.ma_variable) # -> 1 
    print(mon_module2.ma_variable) # -> 2
    print(ma_variable) # -> 3
    print(mon_module2.ma_fonction(ma_variable))
  • Les modules sont des namespaces pour leurs variables : mon_module.ma_variable != mon_module2.mavariables != mavariables

  • Les imports de modules sont transitifs : si on importe module2 qui importe module1 alors on a module1 disponible même si on a pas importé directement module1.

  • Le code d’un module est exécuté au moment de l’import (si ya un print qui traine dans le corps d’un module ça risque de se voir…)

Packages : quand on a beaucoup de code…

On ne s’y retrouve plus avec un seul module ou quelques fichiers à la racine du projet.

  • On met les fichiers dans plusieurs dossiers bien ordonnés

  • On ajoute des fichiers __init__.py dans chaque sous dossiers et ça fait un module

Exemple

Considérant les fichiers suivants :

├── main.py
└── mylib/
    ├── __init__.py
    └── bonjour.py      # <-- Contient "def dire_bonjour..."

Depuis main.py, je peux faire

from mylib.bonjour import dire_bonjour

dire_bonjour("Marius") # -> "Bonjour Marius !"

print(dire_bonjour)
# -> <function dire_bonjour at 0x7fb964fab668>

Considérant les fichiers suivants :

├── main.py
└── mylib/
    ├── __init__.py
    └── bonjour.py      # <-- Contient "def dire_bonjour..."

Depuis main.py, je peux aussi faire

from mylib import bonjour

bonjour.dire_bonjour("Marius") # -> "Bonjour Marius !"

print(bonjour)
# -> <module 'mylib.bonjour' from 'mylib/bonjour.pyc'>

Faire une librairie

Si on a besoin de le distribuer ou simplement pour le séparer du reste du code peut ensuite transformer son package en une librairie installable grâce à un outil nommée setuptools et/ou pip.

Cf. Exercice 4.3

19. Tester son code

Pourquoi Tester ?

“Pour éviter les régressions”

Une modification à un bout du programme peut casser un autre morceau si on y prend pas garde ! Par exemple si on a changer un nom de variable mais pas partout dans le code. Le logiciel a l’air de fonctionner.

Lorsqu’on a un gros logiciel avec une base de code python énorme on ne peut pas facilement connaître tout le code. Même sur un logiciel plus limité on ne peut pas penser à tout.

Comme un logiciel doit pouvoir être en permanence refactorisé pour resté efficace et propre on a vraiment besoin de tests pour tout logiciel d’une certaine taille.

Si vous codez une librairie pour d’autres développeurs/utilisateurs, ces utilisateurs veulent un maximum de tests pour garantir que vous ne laisserait pas des bugs dans la prochaine version et qu’ils peuvent faire confiance à votre code.

Pour anticiper les bugs avant qu’ils n’arrivent

Écrire des bons test nécessite d’imaginer les cas limites de chaque fonction. Si on a oublié de gérer le cas argument = -1 par exemple au moment des tests on peut le remarquer, le corriger et faire en sorte que le test garantisse que ce bug est évité.

Pour aider à coder le programme en réfléchissant à l’avance a ce que chaque fonction doit faire

Écrire des tests avant de coder, une pratique qu’on appelle le Test Driven Development

Deux types de tests: tests unitaires et tests d’intégrations

  • Unitaire: tester chaque fonction et chaque classe. Peur détecter les problèmes locaux à chaque fonction.

  • Intégration: tester l’application en largeur en appelant le programme ou certaines grosses partie dans un contexte plus ou moins réaliste. Pour détecter les problèmes d’intgégration entre plusieurs parties du programme mais déclenche aussi les problèmes dans les fonctions.

  • Généralement les tests unitaires sont très rapides (on peut les lancer toutes les 5 minutes puisque ça prend 4 secondes)

Généralement les tests d'intégration sont plus lent puisqu’il faut initialiser toute l’application et son contexte avant de les lancer.

Test unitaire avec Pytest

Dans mylib.py

def func(x):
    return x + 1

Dans tests.py

from mylib import func

def test_answer():
    assert func(3) == 5

Lancer Pytest

  • En précisant le fichier de test un fichier: pytest tests.py ou python3 -m pytest tests.py si on utilise un environnement virtuel python.

  • En laissant pytest trouver tous les tests du projet : les commandes pytest ou python3 -m pytest parcourt tous les fichiers python du dossier et considère comme des tests toutes les fonctions qui commencent par test_

Tests d’integration exemple avec Flask

Initialiser le contexte de test avec une fixture

(fixture = une fonction de préparation d’un contexte consistant pour les tests)

import os
import tempfile
import pytest

from web_app import web_app

@pytest.fixture
def client():
    with web_app.test_client() as client: # une application flask propose une méthode test_client() pour mettre en place un serveur web destiné aux test
        yield client # pour chaque test la fonction client() renvoie le client de test flask

def test_compute_add_5_5(client): # la fixture client est passée en paramètre de la fonction de test
    return_value = client.get('/add/5/5')
    assert b'5 + 5 = 10' in return_value.data

def test_compute_add_0_0(client):
    return_value = client.get('/add/0/0')
    assert b'0 + 0 = 0' in return_value.data

Ces deux tests s’éxecutent en montant un serveur web et en appelant la route (~page web) correspondante. On aurait pu également initialiser une base de données pour le site web avant de lancer les tests avec une fixture par exemple bdd.

Exercices Partie 4 - Python Object Model, modules et qualité

Exercice 4.1 - Un paquet pythonique

4.1 Utiliser les syntaxes de liste sur la classe Paquet

  • Plutôt que d’utiliser len(mon_paquet.cartes) pour avoir le nombre de carte on voudrait utiliser len(mon_paquet). Implémentez la méthode spéciale __len__ pour renvoyer la longueur du paquet. Profitez-en pour empêcher que les utilisateurs de la classe modifient directement le paquet en rendant l’attribut cartes privé. Testez votre programme en mettant à jour le code main.py

  • Maintenant que l’attribut cartes n’est plus censé être accessible hors de la classe, nous avons besoin d’un nouvelle méthode pour accéder à une carte du paquet depuis le programme principal. Implémentez la méthode spéciale __getitem__ pour pouvoir accéder à une carte avec mon_paquet[position]. Tester la dans le programme principal.

  • Notre Paquet ressemble maintenant beaucoup à une véritable liste python. Essayez dans le main.py d’utiliser la méthode shuffle classique de Python pour mélanger un paquet de carte : Il manque quelque chose.

  • Dans l’interpréteur (python3 ou ipython3) affichez la liste des méthode de la classe paquet en utilisant dir(). Les méthodes en python sont assignées dynamiquement aux classes et peuvent être modifiées au fur et à mesure du programme. Ajoutons une méthode __setitem__ directement depuis l’interpréteur (démo). Affichez à nouveau le dictionnaire dir() de mon_paquet pour voir la nouvelle méthode ajoutée.

  • Ajoutez maintenant __setitem__ dans le code de Paquet. Supprimez et remplacez la méthode melanger par shuffle dans le code du projet.

Exercice 4.2 - Un itérateur de cartes

4.2 Itérateurs de carte : génération de la suite de carte à partir d’une carte

Plutôt que de générer les 52 cartes avec une boucle for dans le constructeur du paquet on voudrait utiliser un générateur/itérateur associé à la classe carte.

  • Ajoutez à carte.py une classe IterateurDeCarte pour générer la suite des cartes à partir d’un objet carte.

    1. D’abord créez la classe IterateurDeCarte qui prend en argument une Carte à la création et qui possède des méthodes __next__(self) qui retourne la carte suivante dans l’ordre des cartes et __iter__ qui lui permet de se renvoyer lui même pour continuer l’itération.
    2. Ajoutez une méthode __iter__ à la classe carte qui renvoie un itérateur basée sur la carte courante.
  • Générez les 52 cartes du paquet à partir de notre iterateur de carte.

  • Ajoutez un paramètre facultatif carte_de_départ au contructeur de paquet pour commencer la génération du paquet à partie d’une carte du milieu de la série de carte possible.

  • Modifiez le constructeur de la classe Carte pour qu’elle prenne en argument des valeurs et couleurs possibles qui ne soit pas les valeurs classique. Testez cette fonctionnalité dans main.py en générant un jeu de “UNO” (sans les cartes “Joker” noire) à la place d’un jeu classique. Cartes de Uno

Bonus : d’autres générateurs de carte

Les listes sont des collections finies et les itérateurs de liste sont donc toujours finis. Cependant un itérateur n’a pas de taille en général et peut parfois renvoyer des valeurs indéfiniment des valeurs (grace à un générateur infini par exemple).

  • Modifiez l’itérateur de carte pour qu’il se base sur un générateur de carte infini utilisant les nombre de la suite de fibonacci et les quatre couleurs du UNO. (Voir correction de fibonacci dans la partie 1)

Exercice 4.3 - fancy operations - Packages, scripts et tests

4.3.1 Créer un script avec des paramètres documentés grâce à docopt

Le point de départ des exercices 4.3 à 4.5 est une librairie de calcul extrêment simple ennuyeuse puisqu’elle fournit des fonctions fancy_add, fancy_substract et fancy_product. Pour illustrer la réutilisation du code et des bonnes pratiques de développement, nous allons cependant la packager et l’utiliser pour contruire un outil de calcul en ligne de commande, et un autre basé sur une application web (cli_calculator.py et web_calculator).

  • Récupérez avec git clone le projet de base à l’adresse https://github.com/e-lie/python202011-exercice-fancy-ops.git. Ouvrez le dans VSCode.

  • Créez un environnement virtuel python3 dans un dossier venv pour travailler de façon isolée des autres projets et de l’environnement python du système: virtualenv -p python3 venv.

  • Activez l’environnement dans votre terminal courant : source ./venv/bin/activate (deactivate pour desactiver l’environnement).

  • Observer les fonctions de calculs présentes dans fancy_operations.py. Créez un script cli_calculator.py qui importe ces trois fonctions et les utilise pour faire des calculs simples.

  • Essayez de debugger le script dans VSCode (normalement la configuration de debug est déjà présente dans car fournit dans le fichier .vscode/launch.json du projet).

  • Installons la librairie externe docopt dans notre environnement virtuel:

    • Ajoutez docopt à un fichier requirements.txt à la racine du projet.
    • Installez cette dépendance grâce au gestionnaire de paquet pip : pip install -r requirements.txt (vérifiez bien que votre venv est activé avec source venv/bin/activate).
  • En vous inspirant du cours et de la documentation de docopt utilisez cette librairie pour faire en sorte que cli_calculator listops affiche la liste des operations disponibles dans fancy_operations.py. On pourra pour cela ajouter dans fancy_operations.py un dictionnaire fancy_operations répertoriant les operations au format { 'add': fancy_add, ... }.

4.3.2 Déplacer les fonctions de calcul dans un package de librairie

Pour ajouter une nouvelle classe vector2d à notre librairie nous allons la réorganiser en plusieurs fichiers et sous dossiers.

  • Créez un dossier computation_libs pour la librairie à la racine du projet. À l’intérieur créer un sous dossier fancy_int_operations pour ranger nos fonctions.

  • Déplacez et rangez les fonctions fancy_add, fancy_product et le dictionnaire fancy_operations à la racine de fancy_int_operations dans un fichier __init__.py de façon à pouvoir les importer dans cli_calculator.py sous la forme from computation_libs.fancy_int_operations import fancy_add, fancy_product, fancy_operations.

  • Déplacez de même fancy_substract de façon à pouvoir l’importer comme suit : from computation_libs.fancy_int_operations.more_fancy_operations import fancy_substract.

  • Vérifiez que votre script cli_calculator.py fonctionne toujours.

  • Ajoutez finalement la classe Vector2d suivante dans un fichier computation_libs/vector2d.py:

vector2d

`computation_libs/vector2d.py`
  • Documentez cette classe grâce à un doctype contenant le texte suivant A 2-dimensional vector class from the fluent python book chapter 9.

4.3.3 Finir cli_calculator

  • Ajoutez dans cli_calculator.py un deuxième cas d’usage docopt permettant d’appeler le script pour effectuer une operation comme suit: python3 cli_calculator.py substract 3 4 affichera 3 - 4 = -1. On pourra préciser le symbole -, +, * en complexifiant le dictionnaire fancy_operations pour indiquer le symbole correspondant à chaque opération.

  • Gérer les mauvaises entrées utilisateurs grâce à un try: ... except:. On pourra afficher un message d’erreur tel que Bad operation or operand (should be integers) et finir le script en erreur grâce à exit(1).

4.3.4 Créer un package python d’application web : web_calculator

  • Dans le dépot du projet récupérez la correction intermédiaire et le début du projet flask en allant sur la branche correction_inter_flask (git checkout <branche>).

  • Ajoutez la librairie web flask aux dépendances du projet et installez la avec pip.

  • Créez un script web_calculator.py avec le code d’une application web de base:

from flask import Flask, render_template

web_app = Flask(__name__)

@web_app.route('/')
def index():
    return render_template("index.html", title="Webcalculator Home")
  • Testez l’application avec flask run ou le lancement VSCode Webcalculator puis visitez http://localhost:5000 dans votre navigateur.

Maintenant que cette application minimale fonction une bonne pratique est d’en faire un package:

  • Créez un package web_app initialisant une application flask quand on l’importe avec le code :
from flask import Flask

web_app = Flask(__name__)
  • Créez un fichier routes.py dans le package avec notre route index et en important correctement les modules nécessaires.

  • Déplacez le dossier templates dans le package également et gardez dans web_calculator.py uniquement from web_app import web_app.

  • Retestez l’application comme précédemment : comment cela fonctionne-t-il au niveau de l’import ?

  • Créez une seconde route def compute(operation, int_n, int_m): en mode GET avec comme url /<operation>/<int_n>/<int_m> qui

    • utilisez la librairie fancy_int_operations pour effectuer des opérations sur des entier int_n et int_m
    • utilise le template jinja operation.html pour afficher le résultat
    • on pourra bien sur debugger l’application dans VSCode ou avec ipdb pour bien comprendre l’exécution et trouver les erreurs.
    • Testez votre application dans le navigateur.

Pour utiliser la librairie computation_libs.fancy_int_operations nous avons du déplacer le package à l’intérieur de web_app pour le rendre accessible à l’application web. Notre cli_calculator ne fonctionne plus du coup.

  • La bonne méthode pour travailler avec des packages indépendants consiste à créer un paquet pip “editable” à partir de notre package:
    • remettez computation_libs à la racine du projet.
    • ajoutez dans computation_libs un fichier de packaging setup.py utilisé par setuptools pour packer notre librairie.
    • mettez à l’intérieur:
from setuptools import setup, find_packages

setup(name='computation-libs', version='0.1', packages=find_packages())
- Installez la librairie avec `pip install -e ./computation_libs`
  • Gérez les mauvaises entrées utilisateur avec un try: except: renvoyant le cas échéant vers le template invalid.html. Testez.

4.3.4 Tester nos modules avec Pytest

  • Ecrire des tests unitaires pytest sur les 3 opérations de notre librairie.

  • Ecrire des test d’intégration sur notre application flask.

Correction:

La correction finale est dans la branche correction_finale du dépôt visible sur github ici

Exercice 4.4 - Application du design pattern observateur

4.4 Design patterns ‘Observateur’ appliquée aux chaînes Youtube

Les design patterns sont des patrons de conception qui permettent de gérer de manière des problèmes génériques qui peuvent survenir dans une grande variété de contextes. L’une d’entre elle est la design pattern “observateur”. Il définit deux types d’entités “observables” et “observateur”. Une observable peut être surveillée par plusieurs observateurs. Lorsque l’état de l’observable change, elle notifie alors tous les observateurs liés qui propage alors le changements.

Concrètement, ceci peut correspondre à des éléments d’interface graphique, des capteurs de surveillances (informatique ou physique), des systemes de logs, ou encore des comptes sur des médias sociaux lorsqu’ils postent de nouveaux messages.

(Reference plus complète : https://design-patterns.fr/observateur )

Nous proposons d’appliquer ce patron de conception pour créer un système avec des journaux / chaines youtube (observables, qui publient des articles / videos) auxquels peuvent souscrire des personnes.

  • Créer deux classes Channel (chaîne youtube) et User (suceptibles de s’abonner)

    • Chaque Channel et User a un nom.
    • La classe Channel implémente des méthodes subscribe et unsubscribe qui ajoutent/enlèvent un compte observateur donné en argument. On introduira également un attribut dans User qui liste les vidéos auxquel un compte est abonné et qui est modifié par les appel de subscribe et unsubscribe.
    • La classe Channel implémente aussi une méthode notifySubscribers qui appelle compte.actualiser() pour chaque compte abonné de la chaîne. Pour le moment, la méthode actualiser de la classe User ne fait rien (pass)
  • Ajoutons une méthode publish à la classe Channel qui permet d’ajouter une vidéo à la liste de vidéo de la chaíne. Chaque vidéo correspondra uniquement à un titre et une date de publication (gérée avec la librairie datetime). Lorsque la méthode publish est appellée, elle déclenche aussi notifySubscribers.

  • La méthode actualiser de la classe User s’occupe de parcourir toutes les chaines auxquelles le compte est abonné, et de récupérer le titre des 3 vidéos les plus récentes parmis toutes ses chaines. Ces 3 titres (et le nom du channel associé!) sont ensuite écris dans latest_videos_for_{username}.txt.

  • Tester l’ensemble du fonctionnement avec un programme tel que:


arte = Channel("ARTE")
cestpassorcier = Channel("c'est pas sorcier")
videodechat = Channel("video de chat")

alice = User("alice")
bob = User("bob")
charlie = User("charlie")

arte.subscribe(alice)
cestpassorcier.subscribe(alice)
cestpassorcier.subscribe(bob)
videodechat.subscribe(bob)
videodechat.subscribe(charlie)

cestpassorcier.publish("Le système solaire")
arte.publish("La grenouille, un animal extraordinaire")
cestpassorcier.publish("Le génie des fourmis")
videodechat.publish("Video de chat qui fait miaou")
cestpassorcier.publish("Les chateaux forts")

Correction 4.1 - Un paquet pythonique

4.1 Utiliser les syntaxes de liste sur la classe Paquet

  • Plutôt que d’utiliser len(mon_paquet.cartes) pour avoir le nombre de carte on voudrait utiliser len(mon_paquet). Implémentez la méthode spéciale __len__ pour renvoyer la longueur du paquet. Profitez-en pour empêcher que les utilisateurs de la classe modifient directement le paquet en rendant l’attribut cartes privé. Testez votre programme en mettant à jour le code main.py

  • Maintenant que l’attribut cartes n’est plus censé être accessible hors de la classe, nous avons besoin d’un nouvelle méthode pour accéder à une carte du paquet depuis le programme principal. Implémentez la méthode spéciale __getitem__ pour pouvoir accéder à une carte avec mon_paquet[position]. Tester la dans le programme principal.

  • Notre Paquet ressemble maintenant beaucoup à une véritable liste python. Essayez dans le main.py d’utiliser la méthode shuffle classique de Python pour mélanger un paquet de carte : Il manque quelque chose.

  • Dans l’interpréteur (python3 ou ipython3) affichez la liste des méthode de la classe paquet en utilisant dir(). Les méthodes en python sont assignées dynamiquement aux classes et peuvent être modifiées au fur et à mesure du programme. Ajoutons une méthode __setitem__ directement depuis l’interpréteur (démo). Affichez à nouveau le dictionnaire dir() de mon_paquet pour voir la nouvelle méthode ajoutée.

  • Ajoutez maintenant __setitem__ dans le code de Paquet. Supprimez et remplacez la méthode melanger par shuffle dans le code du projet.

`carte.py`
`paquet.py`
`main.py`

Correction 4.2 - Un itérateur de cartes

4.2 Itérateurs de carte : génération de la suite de carte à partir d’une carte

Plutôt que de générer les 52 cartes avec une boucle for dans le constructeur du paquet on voudrait utiliser un générateur/itérateur associé à la classe carte.

  • Ajoutez à carte.py une classe IterateurDeCarte pour générer la suite des cartes à partir d’un objet carte.

    1. D’abord créez la classe IterateurDeCarte qui prend en argument une Carte à la création et qui possède des méthodes __next__(self) qui retourne la carte suivante dans l’ordre des cartes et __iter__ qui lui permet de se renvoyer lui même pour continuer l’itération.
    2. Ajoutez une méthode __iter__ à la classe carte qui renvoie un itérateur basée sur la carte courante.
  • Générez les 52 cartes du paquet à partir de notre iterateur de carte.

  • Ajoutez un paramètre facultatif carte_de_départ au contructeur de paquet pour commencer la génération du paquet à partie d’une carte du milieu de la série de carte possible.

  • Modifiez le constructeur de la classe Carte pour qu’elle prenne en argument des valeurs et couleurs possibles qui ne soit pas les valeurs classique. Testez cette fonctionnalité dans main.py en générant un jeu de “UNO” (sans les cartes “Joker” noire) à la place d’un jeu classique. Cartes de Uno

`carte.py`
`paquet.py`
`main.py`

Bonus : d’autres générateurs de carte

Les listes sont des collections finies et les itérateurs de liste sont donc toujours finis. Cependant un itérateur n’a pas de taille en général et peut parfois générer indéfiniment des valeurs (grace à un générateur infini par exemple).

  • Modifiez l’itérateur de carte pour qu’elle se base sur un générateur de carte aléatoire infini.

Correction 4.4 - Application du design pattern observateur

4.4 Design patterns ‘Observateur’ appliquée aux chaînes Youtube

Les design patterns sont des patrons de conception qui permettent de gérer de manière des problèmes génériques qui peuvent survenir dans une grande variété de contextes. L’une d’entre elle est la design pattern “observateur”. Il définit deux types d’entités “observables” et “observateur”. Une observable peut être surveillée par plusieurs observateurs. Lorsque l’état de l’observable change, elle notifie alors tous les observateurs liés qui propage alors le changements.

Concrètement, ceci peut correspondre à des éléments d’interface graphique, des capteurs de surveillances (informatique ou physique), des systemes de logs, ou encore des comptes sur des médias sociaux lorsqu’ils postent de nouveaux messages.

(Reference plus complète : https://design-patterns.fr/observateur )

Nous proposons d’appliquer ce patron de conception pour créer un système avec des journaux / chaines youtube (observables, qui publient des articles / videos) auxquels peuvent souscrire des personnes.

  • Créer deux classes Channel (chaîne youtube) et User (suceptibles de s’abonner)

    • Chaque Channel et User a un nom.
    • La classe Channel implémente des méthodes subscribe et unsubscribe qui ajoutent/enlèvent un compte observateur donné en argument. On introduira également un attribut dans User qui liste les vidéos auxquel un compte est abonné et qui est modifié par les appel de subscribe et unsubscribe.
    • La classe Channel implémente aussi une méthode notifySubscribers qui appelle compte.actualiser() pour chaque compte abonné de la chaîne. Pour le moment, la méthode actualiser de la classe User ne fait rien (pass)
  • Ajoutons une méthode publish à la classe Channel qui permet d’ajouter une vidéo à la liste de vidéo de la chaíne. Chaque vidéo correspondra uniquement à un titre et une date de publication (gérée avec la librairie datetime). Lorsque la méthode publish est appellée, elle déclenche aussi notifySubscribers.

  • La méthode actualiser de la classe User s’occupe de parcourir toutes les chaines auxquelles le compte est abonné, et de récupérer le titre des 3 vidéos les plus récentes parmis toutes ses chaines. Ces 3 titres (et le nom du channel associé!) sont ensuite écris dans latest_videos_for_{username}.txt.

  • Tester l’ensemble du fonctionnement avec un programme tel que:


arte = Channel("ARTE")
cestpassorcier = Channel("c'est pas sorcier")
videodechat = Channel("video de chat")

alice = User("alice")
bob = User("bob")
charlie = User("charlie")

arte.subscribe(alice)
cestpassorcier.subscribe(alice)
cestpassorcier.subscribe(bob)
videodechat.subscribe(bob)
videodechat.subscribe(charlie)

cestpassorcier.publish("Le système solaire")
arte.publish("La grenouille, un animal extraordinaire")
cestpassorcier.publish("Le génie des fourmis")
videodechat.publish("Video de chat qui fait miaou")
cestpassorcier.publish("Les chateaux forts")
correction

Introduction à Flask

Présentation

Une application web

  • On interagit avec au travers d’un navigateur web
    • Avec le navigateur, on accède à des ressources par des URL. Par exemple :
      • La racine du site : /
      • Une page avec un formulaire de contact : /contact
      • Une image stockée sur le site : /chat.jpg
    • On clique sur des liens qui vont demander d’autres ressources (GET)
    • On clique sur des boutons qui peuvent envoyer des informations (POST)

Pourquoi une app web ? (plutôt qu’un logiciel classique)

  • Pros:

    • Cross-platform
    • Mise à jour simple
    • Au niveau technique : distinction plus évidente entre le front et le back-end ?
    • Plus de possibilité et de flexibilité cosmétiques
  • Cons:

    • Moins de vie privée
    • Le web est un désastre au niveau CPU
    • Demnade de connaitre + de technos ? (HTML/CSS/JS)

Flask

Flask

En quelques mots

Un “micro-framework” pour faire du web, composé de plusieurs morceaux

  • Vues gérées avec Jinja (moteur de template avec une syntaxe “à la Python”)
  • Controleurs gérés avec Werkzeug (une URL <-> une fonction)
  • Modèles gérées avec SQLAlchemy (ORM : une classe <-> une table SQL)

On peut y greffer pleins d’autres modules petits modules optionnels

Pour des applications plus grosses, on préferera tout même Django qui est un framework plus complet (mais plus complexe) mais qui suis la même logique

Virtualenv

  • Environnement virtuel
  • Isoler des paquets / dépendances pour utiliser des versions spécifiques
# La premiere fois :
sudo apt install python-virtualenv python3-virtualenv virtualenv

# Creation d'un virtualenv 'venv'
virtualenv -p python3 venv
source venv/bin/activate

# Installation de dependances
pip3 install <une dependance...>
pip3 install <une autre dependance...>


# On développe, on teste, etc....


# Si on a fini et/ou que l'on veut "sortir" du virtualenv
deactivate

Virtualenv “de base” pour Flask

virtualenv -p python3 venv
source venv/bin/activate

pip install Flask
pip install Flask-SQLAlchemy

Hello World en Flask

On associe l’url / à un controleur (= une fonction) qui renvoie Hello World

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

Mon controleur hello_world() doit renvoyer du texte ou une “HTTP response” (par exemple, erreur 404, ou redirection, …)

Hello World en Flask

Lancer le serveur web de test :

$ export FLASK_APP=hello.py
$ flask run
 * Running on http://127.0.0.1:5000/

ensuite, je visite:

http://127.0.0.1:5000/     # -> Affichera 'Hello world'

Hello World en Flask

On peut créer d’autres controleur pour d’autres URLs…

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

@app.route('/python')
def python():
    return "Le python, c'est la vie!"

ensuite :

http://127.0.0.1:5000/python    # -> Affichera 'Le python, c'est la vie!'

Créer des vues avec Jinja

Un template ressemble à :

<html>
  Bonjour {{ prenom }} !

  {% for app in apps %}
    {{ app.name }} est niveau {{ app.level }} !
  {% endfor %}
</html>

On peut l'hydrater avec par exemple ces données :

prenom = "Sacha"
apps = [ { "name": "mailman", "level": 2 },
         { "name": "wordpress", "level": 7 },
         { "name": "nextcloud", "level": 8 }    ]

Créer des vues avec Jinja

Rendu :

<html>
  Bonjour Sacha !

  mailman est niveau 2 !
  wordpress est niveau 7 !
  nextcloud est de niveau 8 !
</html>

Créer des vues avec Jinja

En supposant que le template précédent soit situé dans templates/hello.html, je peux utiliser render_template dans mon controleur générer un rendu à l’aide de mes données

from flask import render_template

@app.route('/')
def homepage():
    apps = [ { "name": "mailman", "level": 2 },
             { "name": "wordpress", "level": 7 },
             { "name": "nextcloud", "level": 8 }    ]
    return render_template('hello.html',
                           name="Sacha",
                           apps=apps)

Gérer les données avec SQL Alchemy

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///./db.sqlite'
db = SQLAlchemy()
db.init_app(app)


class App(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), unique=True, nullable=False)
    level = db.Column(db.Integer, nullable=False)
    date_last_test = db.Column(db.Date, nullable=True)

Gérer les données avec SQL Alchemy

Initialiser les tables

# Supprimer toutes les tables existantes (achtung!)
db.drop_all()

# Recréer toutes les tables qui vont bien
db.create_all()

Gérer les données avec SQL Alchemy

Ecrire

# Creer et ajouter une app dans la database...
mailman = App(name="mailman", level=3)
db.session.add(mailman)
db.session.commit()

Lire

# Trouver toutes les apps..
App.query.all()

# Trouver toutes les apps level 7 ...
App.query.filter_by(level=7).all()

# Trouver l'app qui s'apelle mailman
App.query.filter_by(name="mailman").first()

Gérer les données avec SQL Alchemy

Dans un controleur

from flask import render_template
from my_models import App

@app.route('/')
def homepage():

    apps = App.query.all()

    return render_template('hello.html',
                           prenom="Sacha",
                           apps=apps)

Récupérer une requête

from flask import request
@app.route('/add', methods=['POST','GET'])
def add():
  return request.form["name"]+" "+request.form["level"]

Faire une redirection

from flask import redirect
@app.route('/redirect')
  return redirect('/')

TP de mise en application : gestionnaire de contacts

L'architecture MVC

L’architecture MVC

  • Modèle = les données et la façon dont elles sont structurées…
  • Vue = affichage, mise en forme des données
  • Controleur = la logique qui gère la requête de l’utilisateur, va chercher les données qu’il faut, et les donne à manger à la vue

Pour résumer:

  • D’abord un utilisateur envoie une requête pour voir une page en entrant une URL
  • Cette requête est reçue par le Controleur
  • Le Controleur utilise le modèle pour trouver toutes les données dont il a besoin
  • Puis envoie les données à la Vue qui rend une page web

Bibliographie

Livres

  • Apprendre la programmation avec Python 3 (plutôt complet et orienté débutant)
  • Fluent Python (Ce que pythonique veut dire, comment utiliser Python proprement)
  • Serious Python (problématiques avancées de développement)

Tutoriels

  • Flask Mega Tutorial très long et développé : tutoriel pour coder une application web d’assez grande taille en Python de façon réaliste et illustrant pleins de point du travail de développeur et d’architecture d’application Python :
    • Bases de données
    • Structuration en package
    • Testing
    • Distribution et déploiement de l’application

Articles

Sites de références

Évènements Python

  • PyconFr: https://www.pycon.fr/2020/
  • Cherchez des RDV python près de chez vous.
  • Madhu,Akash2017 - Security automation with Ansible 2 - Packt

Nécessaire

  • Couper les cours en sous pages
  • Refactorer le cours
    • cours sur le Python Data Model -> part4
    • cours sur les tests -> part4
    • cours sur les modules -> part4
  • faire le corrigé de l’exercice XML
  • Faire un exercice sur la mise en module d’un projet
  • Faire un exercice simple pour tester le module
  • Passer les serveurs chez scaleway et formater en modules activables ou non comme dans le truc k8s
  • Ajouter un exercice sur docopt à partir des exercices sur le XML (passer en argument le fichier et la liste de trucs à afficher).
  • Enrichir les cours !!
    • Cours sur les modules et les packages + le concept de namespaces + setuptools
    • Cours sur docopt i.e la doc et le parsing d’arguments
    • Cours sur pytest
    • fixer le certificat HTTPS

Facultatif

  • Comprendre l’exercice avec active_alchemy -> pas sur que ce soit nécessaire de le mettre en tout cas au départ tout comme le cours sur le stockage de données.
  • Faire un exercice pour générer un xml de notre jeu de carte
  • Faire un exercice pour écrire un doctype correcte générer

Moi

Rajouter definition flask propre Est-ce qu’il ont deja fait du sql? detailler virtualenv

Kubernetes

01 - Cours - Présentation de Kubernetes

  • Kubernetes est une solution d’orchestration de conteneurs extrêmement populaire.
  • Le projet est très ambitieux : une façon de considérer son ampleur est de voir Kubernetes comme un système d’exploitation (et un standard ouvert) pour les applications distribuées et le cloud.
  • Le projet est développé en Open Source au sein de la Cloud Native Computing Foundation.

Concrètement : Architecture de Kubernetes

  • Kubernetes rassemble en un cluster et fait coopérer un groupe de serveurs appelés noeuds(nodes).

  • Kubernetes a une architecture Master/workers (cf. cours 2) composée d’un control plane et de nœuds de calculs (workers).

  • Cette architecture permet essentiellement de rassembler les machines en un cluster unique sur lequel on peut faire tourner des “charges de calcul” (workloads) très diverses.

  • Sur un tel cluster le déploiement d’un workload prend la forme de ressources (objets k8s) qu’on décrit sous forme de code et qu’on crée ensuite effectivement via l’API Kubernetes.

  • Pour uniformiser les déploiement logiciel Kubernetes est basé sur le standard des conteneurs (défini aujourd’hui sous le nom Container Runtime Interface, Docker est l’implémentation la plus connue).

  • Plutôt que de déployer directement des conteneurs, Kubernetes crée des aggrégats de un ou plusieurs conteneurs appelés des Pods. Les pods sont donc l’unité de base de Kubernetes.

Philosophie derrière Kubernetes et le mouvement “Cloud Native”

Historique et popularité

Kubernetes est un logiciel développé originellement par Google et basé sur une dizaine d’années d’expérience de déploiement d’applications énormes (distribuées) sur des clusters de machines.

Dans la mythologie Cloud Native on raconte que son ancêtre est l’orchestrateur borg utilisé par Google dans les années 2000.

La première version est sortie en 2015 et k8s est devenu depuis l’un des projets open source les plus populaires du monde.

L’écosystème logiciel de Kubernetes s’est développée autour la Cloud Native Computing Foundation qui comprend notamment : Google, CoreOS, Mesosphere, Red Hat, Twitter, Huawei, Intel, Cisco, IBM, Docker, Univa et VMware. Cette fondation vise au pilotage et au financement collaboratif du développement de Kubernetes (un peut comme la Linux Foundation).

Trois transformations profondes de l’informatique

Kubernetes se trouve au coeur de trois transformations profondes techniques, humaines et économiques de l’informatique:

  • Le cloud
  • La conteneurisation logicielle
  • Le mouvement DevOps

Il est un des projets qui symbolise et supporte techniquement ces transformations. D’où son omniprésence dans les discussions informatiques actuellement.

Le Cloud

  • Au delà du flou dans l’emploi de ce terme, le cloud est un mouvement de réorganisation technique et économique de l’informatique.
  • On retourne à la consommation de “temps de calcul” et de services après une “aire du Personnal Computer”.
  • Pour organiser cela on définit trois niveaux à la fois techniques et économiques de l’informatique:
    • Software as a Service: location de services à travers internet pour les usagers finaux
    • Plateform as a Service: location d’un environnement d’exécution logiciel flexible à destination des développeurs
    • Infrastructure as a Service: location de resources “matérielles” à la demande pour installer des logiciels sans avoir à maintenir un data center.

Conteneurisation

La conteneurisation est permise par l’isolation au niveau du noyau du système d’exploitation du serveur : les processus sont isolés dans des namespaces au niveau du noyau. Cette innovation permet de simuler l’isolation sans ajouter une couche de virtualisation comme pour les machines virtuelles.

Ainsi les conteneurs permettent d’avoir des performances proche d’une application traditionnelle tournant directement sur le système d’exploitation hote et ainsi d’optimiser les ressources.

Les images de conteneurs sont aussi beaucoup plus légers qu’une image de VM ce qui permet de

Les technologies de conteneurisation permettent donc de faire des boîtes isolées avec les logiciels pour apporter l’uniformisation du déploiement:

  • Un façon standard de packager un logiciel (basée sur le)
  • Cela permet d’assembler de grosses applications comme des legos
  • Cela réduit la complexité grâce:
    • à l’intégration de toutes les dépendance déjà dans la boîte
    • au principe d’immutabilité qui implique de jeter les boîtes ( automatiser pour lutter contre la culture prudence). Rend l’infra prédictible.

Les conteneurs sont souvent comparés à l’innovation du porte conteneur pour le transport de marchandise.

Le mouvement DevOps

  • Dépasser l’opposition culturelle et de métier entre les développeurs et les administrateurs système.
  • Intégrer tout le monde dans une seule équipe et …
  • Calquer les rythmes de travail sur l’organisation agile du développement logiciel
  • Rapprocher techniquement la gestion de l’infrastructure du développement avec l’infrastructure as code.
    • Concrètement on écrit des fichiers de code pour gérer les éléments d’infra
    • l’état de l’infrastructure est plus claire et documentée par le code
    • la complexité est plus gérable car tout est déclaré et modifiable au fur et à mesure de façon centralisée
    • l’usage de git et des branches/tags pour la gestion de l’évolution d’infrastructure

Objectifs du DevOps

  • Rapidité (velocity) de déploiement logiciel (organisation agile du développement et livraison jusqu’à plusieurs fois par jour)
    • Implique l’automatisation du déploiement et ce qu’on appelle la CI/CD c’est à dire une infrastructure de déploiement continu à partir de code.
  • Passage à l’échelle (horizontal scaling) des logiciels et des équipes de développement (nécessaire pour les entreprises du cloud qui doivent servir pleins d’utilisateurs)
  • Meilleure organisation des équipes
    • meilleure compréhension globale du logiciel et de son installation de production car le savoir est mieux partagé
    • organisation des équipes par thématique métier plutôt que par spécialité technique (l’équipe scale mieux)

Apports techniques de Kubernetes pour le DevOps

  • Abstraction et standardisation des infrastructures:
  • Langage descriptif et incrémental: on décrit ce qu’on veut plutôt que la logique complexe pour l’atteindre
  • Logique opérationnelle intégrée dans l’orchestrateur: la responsabilité des l’état du cluster est laissé au controlleur k8s ce qui simplifie le travail

On peut alors espérer fluidifier la gestion des défis techniques d’un grosse application et atteindre plus ou moins la livraison logicielle continue (CD de CI/CD)

Architecture logicielle optimale pour Kubernetes

Kubernetes est très versatile et permet d’installer des logiciels traditionnels “monolithiques” (gros backends situés sur une seule machine).

Cependant aux vues des transformations humaines et techniques précédentes, l’organisation de Kubernetes prend vraiment sens pour le développement d’applications microservices:

  • des applications avec de nombreux de “petits” services.
  • chaque service a des problématiques très limitées (gestion des factures = un logiciel qui fait que ça)
  • les services communiquent par le réseaux selon différents modes/API (REST, gRPC, job queues, GraphQL)

Les microservices permettent justement le DevOps car:

  • ils peuvent être déployés séparéments
  • une petite équipe gère chaque service ou groupe thématique de services

Nous y reviendrons pour expliquer l’usage des ressources Kubernetes.

Objets fondamentaux de Kubernetes

  • Les pods Kubernetes servent à grouper des conteneurs fortement couplés en unités d’application
  • Les deployments sont une abstraction pour créer ou mettre à jour (ex : scaler) des groupes de pods.
  • Enfin, les services sont des points d’accès réseau qui permettent aux différents workloads (deployments) de communiquer entre eux et avec l’extérieur.

Au delà de ces trois éléments, l’écosystème d’objets de Kubernetes est vaste et complexe

Kubernetes entre Cloud et auto-hébergement

Un des intérêts principaux de Kubernetes est de fournir un modèle de Plateform as a Service (PaaS) suffisamment versatile qui permet l’interopérabilité entre des fournisseurs de clouds différents et des solutions auto-hébergées (on premise).

Cependant cette interopérabilité n’est pas automatique (pour les cas complexes) car Kubernetes permet beaucoup de variations. Concrètement il existe des variations entre les installations possibles de Kubernetes

Distributions et “flavours” de Kubernetes

Kubernetes est avant tout un ensemble de standards qui peuvent avoir des implémentations concurrentes. Il existe beaucoup de variétés (flavours) de Kubernetes, implémentant concrètement les solutions techniques derrière tout ce que Kubernetes ne fait que définir : solutions réseau, stockage (distribué ou non), loadbalancing, service de reverse proxy (Ingress), autoscaling de cluster (ajout de nouvelles VM au cluster automatiquement), monitoring…

Il est très possible de monter un cluster Kubernetes en dehors de ces fournisseurs, mais cela demande de faire des choix (ou bien une solution opinionated ouverte comme Rancher) et une relative maîtrise d’un nombre varié de sujets (bases de données, solutions de loadbalancing, redondance du stockage…).

C’est là un tradeoff de kubernetes : tout est ouvert et standardisé, mais devant la (relative) complexité et connaissance nécessaire pour mettre en place sa propre solution (de stockage distribué par exemple) il est souvent préférable de louer un cluster chez un fournisseur quitte à retomber dans un certain vendor lock-in (enfermement propriétaire).

Quelques variantes connues de Kubernetes:

  • Google Kubernetes Engine (GKE) (Google Cloud Plateform): L’écosystème Kubernetes développé par Google. Très populaire car très flexible tout en étant l’implémentation de référence de Kubernetes.
  • Azure Kubernetes Services (AKS) (Microsoft Azure): Un écosystème Kubernetes axé sur l’intégration avec les services du cloud Azure (stockage, registry, réseau, monitoring, services de calcul, loadbalancing, bases de données…).
  • Elastic Kubernetes Services (EKS) (Amazon Web Services): Un écosystème Kubernetes assez standard à la sauce Amazon axé sur l’intégration avec le cloud Amazon (la gestion de l’accès, des loadbalancers ou du scaling notamment, le stockage avec Amazon EBS, etc.).
  • Rancher: Un écosystème Kubernetes très complet, assez opinionated et entièrement open-source, non lié à un fournisseur de cloud. Inclut l’installation de stack de monitoring (Prometheus), de logging, de réseau mesh (Istio) via une interface web agréable. Rancher maintient aussi de nombreuses solutions open source, comme par exemple Longhorn pour le stockage distribué.
  • K3S: Un écosystème Kubernetes fait par l’entreprise Rancher et axé sur la légèreté. Il remplace etcd par une base de données Postgres, utilise Traefik pour l’ingress et Klipper pour le loadbalancing.
  • Openshift : Une version de Kubernetes configurée et optimisée par Red Hat pour être utilisée dans son écosystème. Tout est intégré donc plus guidé, avec l’inconvénient d’être un peu captif·ve de l’écosystème et des services vendus par Red Hat.

02 - Cours - Mettre en place un cluster Kubernetes

Architecture de Kubernetes - Partie 1

Kubernetes master
  • Le Kubernetes master est responsable du maintien de l’état souhaité pour votre cluster. Lorsque vous interagissez avec Kubernetes, par exemple en utilisant l’interface en ligne de commande kubectl, vous communiquez avec le master Kubernetes de votre cluster.

  • Le “master” fait référence à un ensemble de processus gérant l’état du cluster. Le master peut également être répliqué pour la disponibilité et la redondance.

Noeuds Kubernetes

Les nœuds d’un cluster sont les machines (serveurs physiques, machines virtuelles, etc.) qui exécutent vos applications et vos workflows. Le master node Kubernetes contrôle chaque noeud; vous interagirez rarement directement avec les nœuds.

  • Pour utiliser Kubernetes, vous utilisez les objets de l’API Kubernetes pour décrire l’état souhaité de votre cluster: quelles applications ou autres processus que vous souhaitez exécuter, quelles images de conteneur elles utilisent, le nombre de réplicas, les ressources réseau et disque que vous mettez à disposition, et plus encore.

  • Vous définissez l’état souhaité en créant des objets à l’aide de l’API Kubernetes, généralement via l’interface en ligne de commande, kubectl. Vous pouvez également utiliser l’API Kubernetes directement pour interagir avec le cluster et définir ou modifier l’état souhaité.

  • Une fois que vous avez défini l’état souhaité, le plan de contrôle Kubernetes (control plane) permet de faire en sorte que l’état actuel du cluster corresponde à l’état souhaité. Pour ce faire, Kubernetes effectue automatiquement diverses tâches, telles que le démarrage ou le redémarrage de conteneurs, la mise à jour du nombre de replicas d’une application donnée, etc.

Le Kubernetes Control Plane

  • Le control plane Kubernetes comprend un ensemble de processus en cours d’exécution sur votre cluster:

    • Le master Kubernetes est un ensemble de trois processus qui s’exécutent sur un seul nœud de votre cluster, désigné comme nœud maître (master node en anglais). Ces processus sont:

      • kube-apiserver: expose l’API pour parler au cluster
      • kube-controller-manager: basé sur une boucle qui controlle en permanence l’état des resources et essaie de le corriger s’il n’est plus conforme.
      • kube-scheduler: monitore les resources des différents workers, décide et cartographie ou doivent être créé les conteneur(Pods)
    • Chaque nœud (master et worker) de votre cluster exécute deux processus : kubelet, qui communique avec le Kubernetes master et controle la création et l’état des pods sur son noeud. kube-proxy, un proxy réseau reflétant les services réseau Kubernetes sur chaque nœud.

Les différentes parties du control plane Kubernetes, telles que les processus kube-controller-manager et kubelet, déterminent la manière dont Kubernetes communique avec votre cluster.

Le control plane conserve un enregistrement de tous les objets Kubernetes du système et exécute des boucles de contrôle continues pour gérer l’état de ces objets. À tout moment, les boucles de contrôle du control plane répondent aux modifications du cluster et permettent de faire en sorte que l’état réel de tous les objets du système corresponde à l’état souhaité que vous avez fourni.

Par exemple, lorsque vous utilisez l’API Kubernetes pour créer un objet Deployment, vous fournissez un nouvel état souhaité pour le système. Le control plane Kubernetes enregistre la création de cet objet et exécute vos instructions en lançant les applications requises et en les planifiant vers des nœuds de cluster, afin que l’état actuel du cluster corresponde à l’état souhaité.

Le client kubectl

…Permet depuis sa machine de travail de contrôler le cluster avec une ligne de commande qui ressemble un peu à celle de Docker (cf. TP1 et TP2):

  • Lister les ressources
  • Créer et supprimer les ressources
  • Gérer les droits d’accès
  • etc.

Cet utilitaire s’installe avec un gestionnaire de paquet classique mais est souvent fourni directement par une distribution de développement de kubernetes.

Nous l’installerons avec snap dans le TP1.

Pour se connecter, kubectl a besoin de l’adresse de l’API Kubernetes, d’un nom d’utilisateur et d’un certificat.

  • Ces informations sont fournies sous forme d’un fichier YAML appelé kubeconfig
  • Comme nous le verrons en TP ces informations sont généralement fournies directement par le fournisseur d’un cluster k8s (provider ou k8s de dev)

Le fichier kubeconfig par défaut se trouve sur Linux à l’emplacement ~/.kube/config.

On peut aussi préciser la configuration au runtime comme ceci: kubectl --kubeconfig=fichier_kubeconfig.yaml <commandes_k8s>

Le même fichier kubeconfig peut stocker plusieurs configurations dans un fichier YAML :

Exemple :

apiVersion: v1

clusters:
- cluster:
    certificate-authority: /home/jacky/.minikube/ca.crt
    server: https://172.17.0.2:8443
  name: minikube
- cluster:
    certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURKekNDQWcrZ0F3SUJBZ0lDQm5Vd0RRWUpLb1pJaHZjTkFRRUxCUUF3TXpFVk1CTUdBMVVFQ2hNTVJHbG4KYVhSaGJFOWpaV0Z1TVJvd0dBWURWUVFERXhGck9<clipped>3SCsxYmtGOHcxdWI5eHYyemdXU1F3NTdtdz09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K
    server: https://5ba26bee-00f1-4088-ae11-22b6dd058c6e.k8s.ondigitalocean.com
  name: do-lon1-k8s-tp-cluster

contexts:
- context:
    cluster: minikube
    user: minikube
  name: minikube
- context:
    cluster: do-lon1-k8s-tp-cluster
    user: do-lon1-k8s-tp-cluster-admin
  name: do-lon1-k8s-tp-cluster
current-context: do-lon1-k8s-tp-cluster

kind: Config
preferences: {}

users:
- name: do-lon1-k8s-tp-cluster-admin
  user:
      token: 8b2d33e45b980c8642105ec827f41ad343e8185f6b4526a481e312822d634aa4
- name: minikube
  user:
    client-certificate: /home/jacky/.minikube/profiles/minikube/client.crt
    client-key: /home/jacky/.minikube/profiles/minikube/client.key

Ce fichier déclare 2 clusters (un local, un distant), 2 contextes et 2 users.

Installation de développement

Pour installer un cluster de développement :

  • solution officielle : Minikube, tourne dans Docker par défaut (ou dans des VMs)
  • solution très pratique et vanilla: kind
  • avec Docker Desktop depuis peu (dans une VM aussi)
  • un cluster léger avec k3s, de Rancher (simple et utilisable en production/edge)

Commander un cluster en tant que service (managed cluster) dans le cloud

Tous les principaux provider de cloud fournissent depuis plus ou moins longtemps des solutions de cluster gérées par eux :

  • Google Cloud Plateform avec Google Kubernetes Engine (GKE) : très populaire car très flexible et l’implémentation de référence de Kubernetes.
  • AWS avec EKS : Kubernetes assez standard mais à la sauce Amazon pour la gestion de l’accès, des loadbalancers ou du scaling.
  • Azure avec AKS : Kubernetes assez standard mais à la sauce Amazon pour la gestion de l’accès, des loadbalancers ou du scaling.
  • DigitalOcean ou Scaleway : un peu moins de fonctions mais plus simple à appréhender

Pour sa qualité on recommande souvent Google GKE qui est plus ancien avec un bonne UX. Mais il s’agit surtout de faciliter l’intégration avec l’existant:

  • Si vous utilisez déjà AWS ou Azure

Installer un cluster de production on premise : l’outil officiel kubeadm

kubeadm est un utilitaire aider générer les certificats et les configurations spéciques pour le control plane et connecter les noeuds au control plane. Il permet également d’effectuer des taches de maintenant comme la mise à jour progressive (rolling) de chaque noeud du cluster.

  • Installer le dæmon Kubelet sur tous les noeuds
  • Installer l’outil de gestion de cluster kubeadm sur un noeud master
  • Générer les bons certificats avec kubeadm
  • Installer un réseau CNI k8s comme flannel (d’autres sont possible et le choix vous revient)
  • Déployer la base de données etcd avec kubeadm
  • Connecter les nœuds worker au master.

L’installation est décrite dans la documentation officielle

Opérer et maintenir un cluster de production Kubernetes “à la main” est très complexe et une tâche à ne pas prendre à la légère. De nombreux éléments doivent être installés et géré par les opérateurs.

  • Mise à jour et passage de version de kubernetes qui doit être fait très régulièrement car une version n’est supportée que 2 ans.
  • Choix d’une configuration réseau et de sécurité adaptée.
  • Installation probable de système de stockage distribué comme Ceph à maintenir également dans le temps
  • Etc.

Kubespray

https://kubespray.io/#/

En réalité utiliser kubeadm directement en ligne de commande n’est pas la meilleure approche car cela ne respecte pas l’infrastructure as code et rend plus périlleux la maintenance/maj du cluster par la suite.

Le projet kubespray est un installer de cluster kubernetes utilisant Ansible et kubeadm. C’est probablement l’une des méthodes les plus populaires pour véritablement gérer un cluster de production on premise.

Mais la encore il s’agit de ne pas sous-estimer la complexité de la maintenance (comme avec kubeadm).

Installer un cluster complètement à la main pour s’exercer

On peut également installer Kubernetes de façon encore plus manuelle pour mieux comprendre ses rouages et composants. Ce type d’installation est décrite par exemple ici : Kubernetes the hard way.

Remarque sur les clusters hybrides

Il est possible de connecter plusieurs clusters ensembles dans le cloud chez plusieurs fournisseurs

03 - TP1 - Installation et configuration de Kubernetes

Au cours de nos TPs nous allons passer rapidement en revue deux manières de mettre en place Kubernetes :

  • Un cluster de développement avec k3s
  • Un cluster managed loué chez un provider (Scaleway, DigitalOcean, Azure ou Google Cloud)

Nous allons d’abord passer par la première option.

Découverte de Kubernetes

Installer le client CLI kubectl

kubectl est le point d’entré universel pour contrôler tous les type de cluster kubernetes. C’est un client en ligne de commande qui communique en REST avec l’API d’un cluster.

Nous allons explorer kubectl au fur et à mesure des TPs. Cependant à noter que :

  • kubectl peut gérer plusieurs clusters/configurations et switcher entre ces configurations
  • kubectl est nécessaire pour le client graphique Lens que nous utiliserons plus tard.

La méthode d’installation importe peu. Pour installer kubectl sur Ubuntu nous ferons simplement: sudo snap install kubectl --classic.

  • Faites kubectl version pour afficher la version du client kubectl.
Bash completion

Pour permettre à kubectl de compléter le nom des commandes et ressources avec <Tab> il est utile d’installer l’autocomplétion pour Bash :

sudo apt install bash-completion

source <(kubectl completion bash)

echo "source <(kubectl completion bash)" >> ${HOME}/.bashrc

Vous pouvez désormais appuyer sur <Tab> pour compléter vos commandes kubectl, c’est très utile !

Installation de k3s

K3s est une distribution de Kubernetes orientée vers la création de petits clusters de production notamment pour l’informatique embarquée et l’Edge computing. Elle a la caractéristique de rassembler les différents composants d’un cluster kubernetes en un seul “binaire” pouvant s’exécuter en mode master (noeud du control plane) ou agent (noeud de calcul).

Avec K3s, il est possible d’installer un petit cluster d’un seul noeud en une commande ce que nous allons faire ici:

  • Lancez dans un terminal la commande suivante: curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="--disable=traefik" sh -

La configuration kubectl pour notre nouveau cluster k3s est dans le fichier /etc/rancher/k3s/k3s.yaml et accessible en lecture uniquement par root. Pour se connecter au cluster on peut donc faire (parmis d’autre méthodes pour gérer la kubeconfig):

  • Créer le répertoire ~/.kube
  • Copie de la conf sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
  • Changer les permission sudo chown $USER ~/.kube/config
  • activer cette configuration pour kubectl avec une variable d’environnement: export KUBECONFIG=~/.kube/config ou rechargez votre terminal
  • Tester la configuration avec kubectl get nodes qui devrait renvoyer quelque chose proche de:
NAME                 STATUS   ROLES                  AGE   VERSION
vnc-stagiaire-...   Ready    control-plane,master   10m   v1.21.7+k3s1

Explorons notre cluster k8s

Notre cluster k8s est plein d’objets divers, organisés entre eux de façon dynamique pour décrire des applications, tâches de calcul, services et droits d’accès. La première étape consiste à explorer un peu le cluster :

  • Listez les nodes pour récupérer le nom de l’unique node (kubectl get nodes) puis affichez ses caractéristiques avec kubectl describe node/<nom du node>.

La commande get est générique et peut être utilisée pour récupérer la liste de tous les types de ressources.

De même, la commande describe peut s’appliquer à tout objet k8s. On doit cependant préfixer le nom de l’objet par son type (ex : node/<nom du node> ou nodes <nom du node>) car k8s ne peut pas deviner ce que l’on cherche quand plusieurs ressources ont le même nom.

  • Pour afficher tous les types de ressources à la fois que l’on utilise : kubectl get all
NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1   <none>        443/TCP   2m34s

Il semble qu’il n’y a qu’une ressource dans notre cluster. Il s’agit du service d’API Kubernetes, pour qu’on puisse communiquer avec le cluster.

En réalité il y en a généralement d’autres cachés dans les autres namespaces. En effet les éléments internes de Kubernetes tournent eux-mêmes sous forme de services et de daemons Kubernetes. Les namespaces sont des groupes qui servent à isoler les ressources de façon logique et en termes de droits (avec le Role-Based Access Control (RBAC) de Kubernetes).

Pour vérifier cela on peut :

  • Afficher les namespaces : kubectl get namespaces

Un cluster Kubernetes a généralement un namespace appelé default dans lequel les commandes sont lancées et les ressources créées si on ne précise rien. Il a également aussi un namespace kube-system dans lequel résident les processus et ressources système de k8s. Pour préciser le namespace on peut rajouter l’argument -n à la plupart des commandes k8s.

  • Pour lister les ressources liées au kubectl get all -n kube-system.

  • Ou encore : kubectl get all --all-namespaces (peut être abrégé en kubectl get all -A) qui permet d’afficher le contenu de tous les namespaces en même temps.

  • Pour avoir des informations sur un namespace : kubectl describe namespace/kube-system

Déployer une application en CLI

Nous allons maintenant déployer une première application conteneurisée. Le déploiement est un peu plus complexe qu’avec Docker, en particulier car il est séparé en plusieurs objets et plus configurable.

  • Pour créer un déploiement en ligne de commande (par opposition au mode déclaratif que nous verrons plus loin), on peut lancer par exemple: kubectl create deployment demonstration --image=monachus/rancher-demo.

Cette commande crée un objet de type deployment. Nous pourvons étudier ce deployment avec la commande kubectl describe deployment/demonstration.

  • Notez la liste des événements sur ce déploiement en bas de la description.

  • De la même façon que dans la partie précédente, listez les pods avec kubectl. Combien y en a-t-il ?

  • Agrandissons ce déploiement avec kubectl scale deployment demonstration --replicas=5

  • kubectl describe deployment/demonstration permet de constater que le service est bien passé à 5 replicas.

    • Observez à nouveau la liste des évènements, le scaling y est enregistré…
    • Listez les pods pour constater

A ce stade impossible d’afficher l’application : le déploiement n’est pas encore accessible de l’extérieur du cluster. Pour régler cela nous devons l’exposer grace à un service :

  • kubectl expose deployment demonstration --type=NodePort --port=8080 --name=demonstration-service

  • Affichons la liste des services pour voir le résultat: kubectl get services

Un service permet de créer un point d’accès unique exposant notre déploiement. Ici nous utilisons le type Nodeport car nous voulons que le service soit accessible de l’extérieur par l’intermédiaire d’un forwarding de port.

Une méthode pour accéder à un service (quel que soit sont type) en mode développement est de forwarder le traffic par l’intermédiaire de kubectl (et des composants kube-proxy installés sur chaque noeuds du cluster).

  • Pour cela on peut par exemple lancer: kubectl port-forward svc/demonstration-service 8080:8080 --address 127.0.0.1
  • Vous pouvez désormais accéder à votre app via via kubectl sur: http://localhost:8080. Quelle différence avec l’exposition précédente via minikube ?

=> Un seul conteneur s’affiche. En effet kubectl port-forward sert à créer une connexion de developpement/debug qui pointe toujours vers le même pod en arrière plan.

Pour exposer cette application en production sur un véritable cluster, nous devrions plutôt avoir recours à un service de type un LoadBalancer. Nous y reviendrons dans le cours sur les objets kubernetes.

Simplifier les lignes de commande k8s

  • Pour gagner du temps on dans les commandes Kubernetes on peut définir un alias: alias kc='kubectl' (à mettre dans votre .bash_profile en faisant echo "alias kc='kubectl'" >> ~/.bash_profile, puis en faisant source ~/.bash_profile).

  • Vous pouvez ensuite remplacer kubectl par kc dans les commandes.

  • Également pour gagner du temps en ligne de commande, la plupart des mots-clés de type Kubernetes peuvent être abrégés :

    • services devient svc
    • deployments devient deploy
    • etc.

La liste complète : https://blog.heptio.com/kubectl-resource-short-names-heptioprotip-c8eff9fb7202

  • Essayez d’afficher les serviceaccounts (users) et les namespaces avec une commande courte.

Une 2e installation : Mettre en place un cluster K8s managé chez le provider de cloud Scaleway

Je vais louer pour vous montrer un cluster kubernetes managé. Vous pouvez également louez le votre si vous préférez en créant un compte chez ce provider de cloud.

La création prend environ 5 minutes.

  • Sur la page décrivant votre cluster, un gros bouton en bas de la page vous incite à télécharger ce même fichier kubeconfig (Download Kubeconfig).

Ce fichier contient la configuration kubectl adaptée pour la connexion à notre cluster.

  • Listez les contextes avec kubectl config get-contexts et affichez les contexte courant avec kubectl config current-context.

  • Changez de contexte avec kubectl config use-context <nom_contexte>.

  • Testons quelle connexion nous utilisons avec avec kubectl get nodes.

  • Observons les derniers évènements arrivés à notre cluster avec kubectl get events --watch.

Au delà de la ligne de commande…

Accéder à la dashboard Kubernetes

Le moyen le plus classique pour avoir une vue d’ensemble des ressources d’un cluster est d’utiliser la Dashboard officielle. Cette Dashboard est généralement installée par défaut lorsqu’on loue un cluster chez un provider.

On peut aussi l’installer dans minikube ou k3s.

Installer Lens

Lens est une interface graphique (un client “lourd”) pour Kubernetes. Elle se connecte en utilisant kubectl et la configuration ~/.kube/config par défaut et nous permettra d’accéder à un dashboard puissant et agréable à utiliser.

Vous pouvez l’installer en lançant ces commandes :

## Ajouter OpenLens
curl -LO https://github.com/MuhammedKalkan/OpenLens/releases/download/v6.5.2-366/OpenLens-6.5.2-366.amd64.deb
sudo dpkg -i OpenLens-6.5.2-366.amd64.deb
  • Lancez l’application OpenLens
  • Explorons ensemble les ressources dans les différentes rubriques et namespaces

04 - Cours - Objets Kubernetes - Partie 1

L’API et les Objets Kubernetes

Utiliser Kubernetes consiste à déclarer des objets grâce à l’API Kubernetes pour décrire l’état souhaité d’un cluster : quelles applications ou autres processus exécuter, quelles images elles utilisent, le nombre de replicas, les ressources réseau et disque que vous mettez à disposition, etc.

On définit des objets généralement via l’interface en ligne de commande et kubectl de deux façons :

  • en lançant une commande kubectl run <conteneur> ..., kubectl expose ...
  • en décrivant un objet dans un fichier YAML ou JSON et en le passant au client kubectl apply -f monpod.yml

Vous pouvez également écrire des programmes qui utilisent directement l’API Kubernetes pour interagir avec le cluster et définir ou modifier l’état souhaité. Kubernetes est complètement automatisable !

La commande apply

Kubernetes encourage le principe de l’infrastructure-as-code : il est recommandé d’utiliser une description YAML et versionnée des objets et configurations Kubernetes plutôt que la CLI.

Pour cela la commande de base est kubectl apply -f object.yaml.

La commande inverse kubectl delete -f object.yaml permet de détruire un objet précédement appliqué dans le cluster à partir de sa description.

Lorsqu’on vient d’appliquer une description on peut l’afficher dans le terminal avec kubectl apply -f myobj.yaml view-last-applied

Globalement Kubernetes garde un historique de toutes les transformations des objets : on peut explorer, par exemple avec la commande kubectl rollout history deployment.

Parenthèse : Le YAML

Kubernetes décrit ses ressources en YAML. A quoi ça ressemble, YAML ?

- marché:
    lieu: Marché de la Place
    jour: jeudi
    horaire:
      unité: "heure"
      min: 12
      max: 20
    fruits:
      - nom: pomme
        couleur: "verte"
        pesticide: avec

      - nom: poires
        couleur: jaune
        pesticide: sans
    légumes:
      - courgettes
      - salade
      - potiron

Syntaxe

  • Alignement ! (2 espaces !!)

  • ALIGNEMENT !! (comme en python)

  • ALIGNEMENT !!! (le défaut du YAML, pas de correcteur syntaxique automatique, c’est bête mais vous y perdrez forcément du temps !)

  • des listes (tirets)

  • des paires clé: valeur

  • Un peu comme du JSON, avec cette grosse différence que le JSON se fiche de l’alignement et met des accolades et des points-virgules

  • les extensions Kubernetes et YAML dans VSCode vous aident à repérer des erreurs

Syntaxe de base d’une description YAML Kubernetes

Les description YAML permettent de décrire de façon lisible et manipulable de nombreuses caractéristiques des ressources Kubernetes (un peu comme un Compose file par rapport à la CLI Docker).

Exemple

Création d’un service simple :

kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  ports:
    - port: 443
      targetPort: 8443
  selector:
    k8s-app: kubernetes-dashboard
  type: NodePort

Remarques de syntaxe :

  • Toutes les descriptions doivent commencer par spécifier la version d’API (minimale) selon laquelle les objets sont censés être créés
  • Il faut également préciser le type d’objet avec kind
  • Le nom dans metadata:\n name: value est également obligatoire.
  • On rajoute généralement une description longue démarrant par spec:

Description de plusieurs ressources

  • On peut mettre plusieurs ressources à la suite dans un fichier k8s : cela permet de décrire une installation complexe en un seul fichier

  • L’ordre n’importe pas car les ressources sont décrites déclarativement c’est-à-dire que:

    • Les dépendances entre les ressources sont déclarées
    • Le control plane de Kubernetes se charge de planifier l’ordre correct de création en fonction des dépendances (pods avant le déploiement, rôle avec l’utilisateur lié au rôle)
    • On préfère cependant les mettre dans un ordre logique pour que les humains puissent les lire.
  • On peut sauter des lignes dans le YAML et rendre plus lisible les descriptions

  • On sépare les différents objets par ---

Objets de base

Les namespaces

Tous les objets Kubernetes sont rangés dans différents espaces de travail isolés appelés namespaces.

Cette isolation permet 3 choses :

  • ne voir que ce qui concerne une tâche particulière (ne réfléchir que sur une seule chose lorsqu’on opère sur un cluster)
  • créer des limites de ressources (CPU, RAM, etc.) pour le namespace
  • définir des rôles et permissions sur le namespace qui s’appliquent à toutes les ressources à l’intérieur.

Lorsqu’on lit ou créé des objets sans préciser le namespace, ces objets sont liés au namespace default.

Pour utiliser un namespace autre que default avec kubectl il faut :

  • le préciser avec l’option -n : kubectl get pods -n kube-system
  • créer une nouvelle configuration dans la kubeconfig pour changer le namespace par defaut.

Kubernetes gère lui-même ses composants internes sous forme de pods et services.

  • Si vous ne trouvez pas un objet, essayez de lancer la commande kubectl avec l’option -A ou --all-namespaces

Les Pods

Un Pod est l’unité d’exécution de base d’une application Kubernetes que vous créez ou déployez. Un Pod représente des process en cours d’exécution dans votre Cluster.

Un Pod encapsule un conteneur (ou souvent plusieurs conteneurs), des ressources de stockage, une IP réseau unique, et des options qui contrôlent comment le ou les conteneurs doivent s’exécuter (ex: restart policy). Cette collection de conteneurs et volumes tournent dans le même environnement d’exécution mais les processus sont isolés.

Un Pod représente une unité de déploiement : un petit nombre de conteneurs qui sont étroitement liés et qui partagent :

  • les mêmes ressources de calcul
  • des volumes communs
  • la même IP donc le même nom de domaine
  • peuvent se parler sur localhost
  • peuvent se parler en IPC
  • ont un nom différent et des logs différents

Chaque Pod est destiné à exécuter une instance unique d’un workload donné. Si vous désirez mettre à l’échelle votre workload, vous devez multiplier le nombre de Pods avec un déploiement.

Pour plus de détail sur la philosophie des pods, vous pouvez consulter ce bon article.

Kubernetes fournit un ensemble de commande pour débugger des conteneurs :

  • kubectl logs <pod-name> -c <conteneur_name> (le nom du conteneur est inutile si un seul)
  • kubectl exec -it <pod-name> -c <conteneur_name> -- bash
  • kubectl attach -it <pod-name>

Enfin, pour debugger la sortie réseau d’un programme on peut rapidement forwarder un port depuis un pods vers l’extérieur du cluster :

  • kubectl port-forward <pod-name> <port_interne>:<port_externe>
  • C’est une commande de debug seulement : pour exposer correctement des processus k8s, il faut créer un service, par exemple avec NodePort.

Pour copier un fichier dans un pod on peut utiliser: kubectl cp <pod-name>:</path/to/remote/file> </path/to/local/file>

Pour monitorer rapidement les ressources consommées par un ensemble de processus il existe les commande kubectl top nodes et kubectl top pods

Un manifeste de Pod

rancher-demo-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: rancher-demo-pod
spec:
  containers:
    - image: monachus/rancher-demo:latest
      name: rancher-demo-container
      ports:
        - containerPort: 8080
          name: http
          protocol: TCP
    - image: redis
      name: redis-container
      ports:
        - containerPort: 6379
          name: http
          protocol: TCP

Rappel sur quelques concepts

Haute disponibilité

  • Faire en sorte qu’un service ait un “uptime” élevé.

On veut que le service soit tout le temps accessible même lorsque certaines ressources manquent :

  • elles tombent en panne
  • elles sont sorties du service pour mise à jour, maintenance ou modification

Pour cela on doit avoir des ressources multiples…

  • Plusieurs serveurs
  • Plusieurs versions des données
  • Plusieurs accès réseau

Il faut que les ressources disponibles prennent automatiquement le relais des ressources indisponibles. Pour cela on utilise en particulier:

  • des “load balancers” : aiguillages réseau intelligents
  • des “healthchecks” : une vérification de la santé des applications

Nous allons voir que Kubernetes intègre automatiquement les principes de load balancing et de healthcheck dans l’orchestration de conteneurs

Répartition de charge (load balancing)

  • Un load balancer : une sorte d'“aiguillage” de trafic réseau, typiquement HTTP(S) ou TCP.
  • Un aiguillage intelligent qui se renseigne sur plusieurs critères avant de choisir la direction.

Cas d’usage :

  • Éviter la surcharge : les requêtes sont réparties sur différents backends pour éviter de les saturer.

L’objectif est de permettre la haute disponibilité : on veut que notre service soit toujours disponible, même en période de panne/maintenance.

  • Donc on va dupliquer chaque partie de notre service et mettre les différentes instances derrière un load balancer.

  • Le load balancer va vérifier pour chaque backend s’il est disponible (healthcheck) avant de rediriger le trafic.

  • Répartition géographique : en fonction de la provenance des requêtes on va rediriger vers un datacenter adapté (+ proche).

Healthchecks

Fournir à l’application une façon d’indiquer qu’elle est disponible, c’est-à-dire :

  • qu’elle est démarrée (liveness)
  • qu’elle peut répondre aux requêtes (readiness).

Application microservices

  • Une application composée de nombreux petits services communiquant via le réseau. Le calcul pour répondre à une requête est décomposé en différente parties distribuées entre les services. Par exemple:

  • un service est responsable de la gestion des clients et un autre de la gestion des commandes.

  • Ce mode de développement implique souvent des architectures complexes pour être mis en oeuvre et kubernetes est pensé pour faciliter leur gestion à grande échelle.

  • Imaginez devoir relancer manuellement des services vitaux pour une application en hébergeant des centaines d’instances : c’est en particulier à ce moment que kubernetes devient indispensable.

2 exemples d’application microservices:

L’architecture découplée des services Kubernetes

Comme nous l’avons vu dans le TP1, déployer une application dans kubernetes demande plusieurs étapes. En réalité en plus des pods l’ensemble de la gestion d’un service applicatif se décompose dans Kubernetes en 3 à 4 objets articulés entre eux:

  • replicatset
  • deployment
  • service
  • (ingress)

Les Deployments (deploy)

Les déploiements sont les objets effectivement créés manuellement lorsqu’on déploie une application. Ce sont des objets de plus haut niveau que les pods et replicaset et les pilote pour gérer un déploiement applicatif.

Les poupées russes Kubernetes : un Deployment contient un ReplicaSet, qui contient des Pods, qui contiennent des conteneurs

Si c’est nécessaire d’avoir ces trois types de ressources c’est parce que Kubernetes respecte un principe de découplage des responsabilités.

La responsabilité d’un déploiement est de gérer la coexistence et le tracking de versions multiples d’une application et d’effectuer des montées de version automatiques en haute disponibilité en suivant une RolloutStrategy (CF. TP optionnel).

Ainsi lors des changements de version, un seul deployment gère automatiquement deux replicasets contenant chacun une version de l’application : le découplage est nécessaire.

Un deployment implique la création d’un ensemble de Pods désignés par une étiquette label et regroupé dans un Replicaset.

Exemple :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.7.9
          ports:
            - containerPort: 80
  • Pour les afficher : kubectl get deployments

  • La commande kubectl run sert à créer un deployment à partir d’un modèle. Il vaut mieux utilisez apply -f.

Les ReplicaSets (rs)

Dans notre modèle, les ReplicaSet servent à gérer et sont responsables pour:

  • la réplication (avoir le bon nombre d’instances et le scaling)

  • la santé et le redémarrage automatique des pods de l’application (Self-Healing)

  • kubectl get rs pour afficher la liste des replicas.

En général on ne les manipule pas directement (c’est déconseillé) même s’il est possible de les modifier et de les créer avec un fichier de ressource. Pour créer des groupes de conteneurs on utilise soit un Deployment soit d’autres formes de workloads (DaemonSet, StatefulSet, Job) adaptés à d’autres cas.

Les Services

Dans Kubernetes, un service est un objet qui :

  • Désigne un ensemble de pods (grâce à des tags) généralement géré par un déploiement.
  • Fournit un endpoint réseau pour les requêtes à destination de ces pods.
  • Configure une politique permettant d’y accéder depuis l’intérieur ou l’extérieur du cluster.

L’ensemble des pods ciblés par un service est déterminé par un selector.

Par exemple, considérons un backend de traitement d’image (stateless, c’est-à-dire ici sans base de données) qui s’exécute avec 3 replicas. Ces replicas sont interchangeables et les frontends ne se soucient pas du backend qu’ils utilisent. Bien que les pods réels qui composent l’ensemble backend puissent changer, les clients frontends ne devraient pas avoir besoin de le savoir, pas plus qu’ils ne doivent suivre eux-mêmes l’état de l’ensemble des backends.

L’abstraction du service permet ce découplage : les clients frontend s’addressent à une seule IP avec un seul port dès qu’ils ont besoin d’avoir recours à un backend. Les backends vont recevoir la requête du frontend aléatoirement.

Les Services sont de trois types principaux :

  • ClusterIP: expose le service sur une IP interne au cluster. Les autres pods peuvent alors accéder au service de l’intérieur du cluster, mais il n’est pas l’extérieur.

  • NodePort: expose le service depuis l’IP de chacun des noeuds du cluster en ouvrant un port directement sur le nœud, entre 30000 et 32767. Cela permet d’accéder aux pods internes répliqués. Comme l’IP est stable on peut faire pointer un DNS ou Loadbalancer classique dessus.

Crédits à Ahmet Alp Balkan pour les schémas

  • LoadBalancer: expose le service en externe à l’aide d’un Loadbalancer de fournisseur de cloud. Les services NodePort et ClusterIP, vers lesquels le Loadbalancer est dirigé sont automatiquement créés.

Crédits Ahmet Alp Balkan

Les autres types de Workloads Kubernetes

En plus du déploiement d’un application, Il existe pleins d’autre raisons de créer un ensemble de Pods:

  • Le DaemonSet: Faire tourner un agent ou démon sur chaque nœud, par exemple pour des besoins de monitoring, ou pour configurer le réseau sur chacun des nœuds.
  • Le Job : Effectuer une tache unique de durée limitée et ponctuelle, par exemple de nettoyage d’un volume ou la préparation initiale d’une application, etc.
  • Le CronJob : Effectuer une tache unique de durée limitée et récurrente, par exemple de backup ou de régénération de certificat, etc.

De plus même pour faire tourner une application, les déploiements ne sont pas toujours suffisants. En effet ils sont peu adaptés à des applications statefull comme les bases de données de toutes sortes qui ont besoin de persister des données critiques. Pour celà on utilise un StatefulSet que nous verrons par la suite.

Étant donné les similitudes entre les DaemonSets, les StatefulSets et les Deployments, il est important de comprendre un peu précisément quand les utiliser.

Les Deployments (liés à des ReplicaSets) doivent être utilisés :

  • lorsque votre application est complètement découplée du nœud
  • que vous pouvez en exécuter plusieurs copies sur un nœud donné sans considération particulière
  • que l’ordre de création des replicas et le nom des pods n’est pas important
  • lorsqu’on fait des opérations stateless

Les DaemonSets doivent être utilisés :

  • lorsqu’au moins une copie de votre application doit être exécutée sur tous les nœuds du cluster (ou sur un sous-ensemble de ces nœuds).

Les StatefulSets doivent être utilisés :

  • lorsque l’ordre de création des replicas et le nom des pods est important
  • lorsqu’on fait des opérations stateful (écrire dans une base de données)

Jobs

Les jobs sont utiles pour les choses que vous ne voulez faire qu’une seule fois, comme les migrations de bases de données ou les travaux par lots. Si vous exécutez une migration en tant que Pod dans un deployment:

  • Dès que la migration se finit le processus du pod s’arrête.
  • Le replicaset qui détecte que l'“application” s’est arrêter va tenter de la redémarrer en recréant le pod.
  • Votre tâche de migration de base de données se déroulera donc en boucle, en repeuplant continuellement la base de données.

CronJobs

Comme des jobs, mais se lancent à un intervalle régulier, comme les cron sur les systèmes unix.

05 - TP 2 - Déployer en utilisant des fichiers ressource et Lens

Dans ce court TP nous allons redéployer notre application demonstration du TP1 mais cette fois en utilisant kubectl apply -f et en visualisant le résultat dans Lens.

N’hésitez pas aussi à observer les derniers évènements arrivés à votre cluster avec kubectl get events --watch.

  • Changez de contexte pour k3s avec kubectl config use-context k3s ou kubectl config use-context default
  • Chargez également la configuration de k3s dans Lens en cliquant à nouveau sur plus et en selectionnant k3s ou default
  • Commencez par supprimer les ressources demonstration et demonstration-service du TP1
  • Créez un dossier TP2_deploy_using_files_and_Lens sur le bureau de la machine distante et ouvrez le avec VSCode.

Nous allons d’abord déployer notre application comme un simple Pod (non recommandé mais montré ici pour l’exercice).

  • Créez un fichier demo-pod.yaml avec à l’intérieur le code d’exemple suivant :

rancher-demo-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: rancher-demo-pod
spec:
  containers:
    - image: monachus/rancher-demo:latest
      name: rancher-demo-container
      ports:
        - containerPort: 8080
          name: http
          protocol: TCP
    - image: redis
      name: redis-container
      ports:
        - containerPort: 6379
          name: http
          protocol: TCP
  • Appliquez le ficher avec kubectl apply -f <fichier>
  • Constatez dans Lens dans la partie pods que les deux conteneurs du pod sont bien démarrés (deux petits carrés vert à droite de la ligne du pod)
  • Modifiez le nom du pod dans la description précédente et réappliquez la configuration. Kubernetes crée un nouveau pod à ce nom.
  • Modifier le nom du conteneur rancher-demo et réappliquez la configuration. Que se passe-t-il ?

=> Kubernetes refuse d’appliquer le nouveau nom de conteneur car un pod est largement immutable. Pour changer d’une quelquonque façon les conteneurs du pod il faut supprimer (kubectl delete -f <fichier>) et recréer le pod. Mais ce travail de mise à jour devrais être géré par un déploiement pour automatiser et pour garantir la haute disponibilité de notre application demonstration.

Kubernetes fournit un ensemble de commande pour débugger des conteneurs :

  • kubectl logs <pod-name> -c <conteneur_name> (le nom du conteneur est inutile si un seul)

  • kubectl exec -it <pod-name> -c <conteneur_name> -- bash

  • kubectl attach -it <pod-name>

  • Explorez le pod avec la commande kubectl exec -it <pod-name> -c <conteneur_name> -- bash écrite plus haut.

  • Supprimez le pod.

Avec un déploiement (méthode à utiliser)

  • Créez un fichier demo-deploy.yaml avec à l’intérieur le code suivant à compléter:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demonstration
  labels:
    nom-app: demonstration
    partie: objet-deploiement
spec:
  selector:
    matchLabels:
      nom-app: demonstration
      partie: les-petits-pods-demo
  strategy:
    type: Recreate
  replicas: 1
  template:
    metadata:
      labels:
        nom-app: demonstration
        partie: les-petits-pods-demo
    spec:
      containers:
        - image: <image>
          name: <name>
          ports:
            - containerPort: <port>
              name: demo-http
  • Appliquez ce nouvel objet avec kubectl.
  • Inspectez le déploiement dans Lens.
  • Changez le nom d’un conteneur et réappliquez: Cette fois le déploiement se charge créer un nouveau pod avec les bonnes caractéristiques et de supprimer l’ancien.
  • Changez le nombre de réplicats.

Ajoutons un service en mode NodePort

  • Créez un fichier demo-svc.yaml avec à l’intérieur le code suivant à compléter:
apiVersion: v1
kind: Service
metadata:
  name: demo-service
  labels:
    nom-app: demonstration
    partie: le-fameux-service-demo
spec:
  ports:
    - port: <port>
  selector:
    nom-app: demonstration
    partie: les-petits-pods-demo
  type: NodePort
  • Appliquez ce nouvel objet avec kubectl.
  • Inspectez le service dans Lens.
  • Visitez votre application avec l’Internal ip du noeud (à trouver dans les information du node) et le nodeport (port 3xxxx) associé au service, le nombre de réplicat devrait apparaître.
  • Pour tester, changez le label du selector dans le service (lignes nom-app: demonstration et partie: les-petits-pods-demo à remplacer dans le fichier ) et réappliquez.
  • Constatez que l’application n’est plus accessible dans le navigateur. Pourquoi ?
  • Allez voir la section endpoints dans lens, constatez que quand l’étiquette est la bonne la liste des IPs des pods est présente et après la modification du selector la liste est vide (None)

=> Les services kubernetes redirigent le trafic basés sur les étiquettes (labels) appliquées sur les pods du cluster. Il faut donc de même éviter d’utiliser deux fois le même label pour des parties différentes de l’application.

Solution

Le dépôt Git de la correction de ce TP est accessible ici : git clone -b correction_k8s_tp2 https://github.com/Uptime-Formation/corrections_tp.git

06 - Rappels Docker

Les Dockerfiles

Les volumes et les conteneurs

Pour un exemple docker que nous allons réutiliser dans le TP3 vous pouvez cloner le code suivant: git clone -b correction_k8s_tp2 https://github.com/Uptime-Formation/corrections_tp.git

07 - TP 3 - Déployer des conteneurs de A à Z

Récupérez le projet de base : git clone -b exercice https://github.com/Uptime-Formation/tp3-k8s.git tp3. On peut ouvrir une fenêtre VSCode directement dans le dossier qui nous intéresse avec : code tp3.

Ce TP va consister à créer des objets Kubernetes pour déployer une application microservices (plutôt simple) : monsterstack. Elle est composée :

  • d’un front-end en Flask (Python) appelé monstericon,
  • d’un service de backend qui génère des images (un avatar de monstre correspondant à une chaîne de caractères) appelé dnmonster
  • et d’un datastore redis servant de cache pour les images de monstericon

Nous allons également utiliser le builder kubernetes skaffold pour déployer l’application en mode développement : l’image du frontend monstericon sera construite à partir du code source présent dans le dossier app et automatiquement déployée dans minikube.

Etudions le code et testons avec docker compose

  • Monstericon est une application web python (flask) qui propose un petit formulaire et lance une requete sur le backend pour chercher une image et l’afficher.
  • Monstericon est construit à partir du Dockerfile présent dans le dossier TP3.
  • Le fichier docker-compose.yml est utile pour faire tourner les trois services de l’application dans docker rapidement (plus simple que kubernetes)

Pour lancer l’application il suffit :

  1. d’installer Docker avec : curl https://get.docker.com | sudo sh -
  2. puis d’exécuter : sudo docker compose up -d
  3. on peut afficher l’install avec sudo docker compose ps et les logs avec sudo docker compose logs -f

Passons maintenant à Kubernetes.

Utiliser Kompose (facultatif)

Explorer avec Kompose comment on peut traduire un fichier docker-compose.yml en ressources Kubernetes (ce sont les instructions à la page suivante : https://kubernetes.io/fr/docs/tasks/configure-pod-container/translate-compose-kubernetes/).

D’abord, installons Kompose :

# Linux
curl -L https://github.com/kubernetes/kompose/releases/download/v1.26.1/kompose-linux-amd64 -o kompose

chmod +x kompose
sudo mv ./kompose /usr/local/bin/kompose

Puis, utilisons la commande kompose convert et observons les fichiers générés. Ces fichiers ne sont pas très complets, supprimons-les.

Déploiements pour le backend d’image dnmonster et le datastore redis

Maintenant nous allons également créer un déploiement pour dnmonster:

  • créez dnmonster.yaml dans le dossier k8s-deploy-dev et collez-y le code suivant :

dnmonster.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dnmonster
  labels:
    app: monsterstack
spec:
  selector:
    matchLabels:
      app: monsterstack
      partie: dnmonster
  strategy:
    type: Recreate
  replicas: 5
  template:
    metadata:
      labels:
        app: monsterstack
        partie: dnmonster
    spec:
      containers:
        - image: amouat/dnmonster:1.0
          name: dnmonster
          ports:
            - containerPort: 8080
              name: dnmonster
  • Ensuite, configurons un deuxième deployment redis.yaml:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
  labels:
    app: monsterstack
spec:
  selector:
    matchLabels:
      app: monsterstack
      partie: redis
  strategy:
    type: Recreate
  replicas: 1
  template:
    metadata:
      labels:
        app: monsterstack
        partie: redis
    spec:
      containers:
        - image: redis:latest
          name: redis
          ports:
            - containerPort: 6379
              name: redis
  • Appliquez ces ressources avec kubectl apply -f k8s-deploy-dev/ et vérifiez dans Lens que les 5 + 1 réplicats sont bien lancés.

Déploiement du frontend monstericon

Ajoutez au fichier monstericon.yml du dossier k8s-deploy-dev le code suivant:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: monstericon
  labels:
    app: monsterstack
spec:
  selector:
    matchLabels:
      app: monsterstack
      partie: monstericon
  strategy:
    type: Recreate
  replicas: 3
  template:
    metadata:
      labels:
        app: monsterstack
        partie: monstericon
    spec:
      containers:
        - name: monstericon
          image: monstericon
          ports:
            - containerPort: 5000

Skaffold (optionnel)

L’image monstericon de ce déploiement n’existe pas sur le Docker Hub, et notre Kubernetes doit pouvoir accéder à la nouvelle version de l’image construite à partir du Dockerfile. Nous allons utiliser skaffold pour cela. Il y a plusieurs possibilités :

  • utiliser minikube : minikube a la capacité de se connecter au registry de notre installation Docker locale
  • sur k3s ou sur un cluster cloud : pousser à chaque itération notre image sur un registry distant (Docker Hub)
    • pour ce faire, il faut éditer le fichier skaffold.yaml et le fichier de Deployment correspondant pour remplacer le nom de l’image monstericon pour faire référence à l’adresse à laquelle on souhaite pousser l’image sur le registry distant (ex: docker.io/MON_COMPTE_DOCKER_HUB/monstericon)
    • il est possible qu’il faille ajouter au même niveau que artifacts: dans le fichier skaffold.yaml ceci :
  local:
    push: true
  • heureusement le mécanisme de layers des images Docker ne nous oblige à uploader que les layers modifiés de notre image à chaque build

  • (plus long) configurer un registry local (en Docker ou en Kubernetes) auquel Skaffold et Kubernetes peuvent accéder

    • c’est plus long car il faut simplement configurer les certificats HTTPS ou expliciter que l’on peut utiliser un registry non sécurisé (HTTP)
    • ensuite il suffit de déployer un registry tout simple (l’image officielle registry:2) ou plus avancé (Harbour par exemple)
  • (plus avancé) utiliser Kaniko, un programme de Google qui permet de builder directement dans le cluster Kubernetes : https://skaffold.dev/docs/pipeline-stages/builders/docker/#dockerfile-in-cluster-with-kaniko

  • Observons le fichier skaffold.yaml

  • Lancez skaffold run pour construire et déployer l’application automatiquement (skaffold utilise ici le registry docker local et kubectl)

Une image pour monstericon

L’image monstericon de ce déploiement n’existe pas sur le Docker Hub, et notre Kubernetes doit pouvoir accéder à la nouvelle version de l’image construite à partir du Dockerfile.

Sans un outil comme Skaffold, nous sommes bloqué·es : il faut construire l’image à la main et la pousser dans un registry joignable par notre install.

Voici l’image déjà poussée par le formateur : docker.io/uptimeformation/monstericon

Santé du service avec les Probes

  • Ajoutons des healthchecks au conteneur dans le pod avec la syntaxe suivante (le mot-clé livenessProbe doit être à la hauteur du i de image:) :
livenessProbe:
  tcpSocket: # si le socket est ouvert c'est que l'application est démarrée
    port: 5000
  initialDelaySeconds: 5 # wait before firt probe
  timeoutSeconds: 1 # timeout for the request
  periodSeconds: 10 # probe every 10 sec
  failureThreshold: 3 # fail maximum 3 times
readinessProbe:
  httpGet:
    path: /healthz # si l'application répond positivement sur sa route /healthz c'est qu'elle est prête pour le traffic
    port: 5000
    httpHeaders:
      - name: Accept
        value: application/json
  initialDelaySeconds: 5
  timeoutSeconds: 1
  periodSeconds: 10
  failureThreshold: 3

La livenessProbe est un test qui s’assure que l’application est bien en train de tourner. S’il n’est pas rempli le pod est automatiquement supprimé et recréé en attendant que le test fonctionne.

Ainsi, k8s sera capable de savoir si notre conteneur applicatif fonctionne bien, quand le redémarrer. C’est une bonne pratique pour que le replicaset Kubernetes sache quand redémarrer un pod et garantir que notre application se répare elle même (self-healing).

Cependant une application peut être en train de tourner mais indisponible pour cause de surcharge ou de mise à jour par exemple. Dans ce cas on voudrait que le pod ne soit pas détruit mais que le traffic évite l’instance indisponible pour être renvoyé vers un autre backend ready.

La readinessProbe est un test qui s’assure que l’application est prête à répondre aux requêtes en train de tourner. S’il n’est pas rempli le pod est marqué comme non prêt à recevoir des requêtes et le service évitera de lui en envoyer.

Configuration d’une application avec des variables d’environnement simples

  • Notre application monstericon peut être configurée en mode DEV ou PROD. Pour cela elle attend une variable d’environnement CONTEXT pour lui indiquer si elle doit se lancer en mode PROD ou en mode DEV. Ici nous mettons l’environnement DEV en ajoutant (aligné avec la livenessProbe):
env:
  - name: CONTEXT
    value: DEV

Ajouter des indications de ressource nécessaires pour garantir la qualité de service

  • Ajoutons aussi des contraintes sur l’usage du CPU et de la RAM, en ajoutant à la même hauteur que env: :
resources:
  requests:
    cpu: "100m" # 10% de proc
    memory: "50Mi"
  limits:
    cpu: "300m" # 30% de proc
    memory: "200Mi"

Nos pods auront alors la garantie de disposer d’un dixième de CPU (100/1000) et de 50 mégaoctets de RAM. Ce type d’indications permet de remplir au maximum les ressources de notre cluster tout en garantissant qu’aucune application ne prend toute les ressources à cause d’un fuite mémoire etc.

  • Relancer skaffold run pour appliquer les modifications.
  • Avec kubectl describe deployment monstericon, lisons les résultats de notre readinessProbe, ainsi que comment s’est passée la stratégie de déploiement type: Recreate.

Exposer notre stack avec des services

Les services K8s sont des endpoints réseaux qui balancent le trafic automatiquement vers un ensemble de pods désignés par certains labels. Ils sont un peu la pierre angulaire des applications microservices qui sont composées de plusieurs sous parties elles même répliquées.

Pour créer un objet Service, utilisons le code suivant, à compléter :

apiVersion: v1
kind: Service
metadata:
  name: <nom_service>
  labels:
    app: monsterstack
spec:
  ports:
    - port: <port>
  selector:
    app: <app_selector>
    partie: <tier_selector>
  type: <type>
---

Ajoutez le code précédent au début de chaque fichier déploiement. Complétez pour chaque partie de notre application :

  • le nom du service (name: dans metadata:) par le nom de notre programme. En particulier, il faudra forcément appeler les services redis et dnmonster comme ça car cela permet à Kubernetes de créer les entrées DNS correspondantes. Le pod monstericon pourra ainsi les joindre en demandant à Kubernetes l’IP derrière dnmonster et redis.
  • nom de la partie par le nom de notre programme (monstericon, dnmonster et redis)
  • le port par le port du service
  • les selectors app et partie par ceux du pod correspondant.

Le type sera : ClusterIP pour dnmonster et redis, car ce sont des services qui n’ont à être accédés qu’en interne, et LoadBalancer pour monstericon.

  • Appliquez à nouveau avec skaffold run.
  • Listez les services avec kubectl get services.
  • Visitez votre application dans le navigateur avec minikube service monstericon.
  • Supprimez l’application avec skaffold delete.

Ajoutons un ingress (~ reverse proxy) pour exposer notre application en http

  • Pour Minikube : Installons le contrôleur Ingress Nginx avec minikube addons enable ingress.

  • Pour les autres types de cluster (cloud ou k3s), lire la documentation sur les prérequis pour les objets Ingress et installez l’ingress controller appelé ingress-nginx : https://kubernetes.io/docs/concepts/services-networking/ingress/#prerequisites. Si besoin, aidez-vous du TP suivant sur l’utilisation de Helm.

  • Avant de continuer, vérifiez l’installation du contrôleur Ingress Nginx avec kubectl get svc -n ingress-nginx ingress-nginx-controller : le service ingress-nginx-controller devrait avoir une IP externe.

Il s’agit d’une implémentation de reverse proxy dynamique (car ciblant et s’adaptant directement aux objets services k8s) basée sur nginx configurée pour s’interfacer avec un cluster k8s.

  • Repassez le service monstericon en mode ClusterIP. Le service n’est plus accessible sur un port. Nous allons utiliser l’ingress à la place pour afficher la page.

  • Ajoutez également l’objet Ingress suivant dans le fichier monster-ingress.yaml :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: monster-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: monsterstack.local # à changer si envie/besoin
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: monstericon
                port:
                  number: 5000
  • Ajoutez ce fichier avec skaffold run.

  • Récupérez l’ip de minikube avec minikube ip, (ou alors allez observer l’objet Ingress dans Lens dans la section Networking. Sur cette ligne, récupérez l’ip de minikube en 192.x.x.x.).

  • Ajoutez la ligne <ip-minikube> monsterstack.local au fichier /etc/hosts avec sudo nano /etc/hosts puis CRTL+S et CTRL+X pour sauver et quitter.

  • Visitez la page http://monsterstack.local pour constater que notre Ingress (reverse proxy) est bien fonctionnel.

Solution

Le dépôt Git de la correction de ce TP est accessible ici : git clone -b tp3 https://github.com/Uptime-Formation/corrections_tp.git

08 - Cours - Le réseau dans Kubernetes

Les solutions réseau dans Kubernetes ne sont pas standard. Il existe plusieurs façons d’implémenter le réseau.

Rappel, les objets Services

Les Services sont de trois types principaux :

  • ClusterIP: expose le service sur une IP interne au cluster appelée ClusterIP. Les autres pods peuvent alors accéder au service mais pas l’extérieur.

  • NodePort: expose le service depuis l’IP publique de chacun des noeuds du cluster en ouvrant port directement sur le nœud, entre 30000 et 32767. Cela permet d’accéder aux pods internes répliqués. Comme l’IP est stable on peut faire pointer un DNS ou Loadbalancer classique dessus.

    • Dans la pratique, on utilise très peu ce type de service.

Crédits à Ahmet Alp Balkan pour les schémas

  • LoadBalancer: expose le service en externe à l’aide d’un Loadbalancer de fournisseur de cloud. Les services NodePort et ClusterIP, vers lesquels le Loadbalancer est dirigé sont automatiquement créés.
    • Dans la pratique, on utilise que ponctuellement ce type de service, pour du HTTP/s on ne va pas exposer notre service (ce sera un service de type ClusterIP) et on va utiliser à la place un objet Ingress (voir ci-dessous).

Crédits Ahmet Alp Balkan

Fournir des services LoadBalancer on premise avec MetalLB

Dans un cluster managé provenant d’un fournisseur de cloud, la création d’un objet Service Lodbalancer entraine le provisionning d’une nouvelle machine de loadbalancing à l’extérieur du cluster avec une IPv4 publique grâce à l’offre d’IaaS du provideur (impliquant des frais supplémentaires).

Cette intégration n’existe pas par défaut dans les clusters de dev comme minikube ou les cluster on premise (le service restera pending et fonctionnera comme un NodePort). Le projet MetalLB cherche à y remédier en vous permettant d’installer un loadbalancer directement dans votre cluster en utilisant une connexion IP classique ou BGP pour la haute disponibilité.

Les objets Ingresses

Crédits Ahmet Alp Balkan

Un Ingress est un objet pour gérer dynamiquement le reverse proxy HTTP/HTTPS dans Kubernetes. Documentation: https://kubernetes.io/docs/concepts/services-networking/ingress/#what-is-ingress

Exemple de syntaxe d’un ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-wildcard-host
spec:
  rules:
  - host: "domain1.bar.com"
    http:
      paths:
      - pathType: Prefix
        path: "/bar"
        backend:
          service:
            name: service1
            port:
              number: 80
      - pathType: Prefix
        path: "/foo"
        backend:
          service:
            name: service2
            port:
              number: 80
  - host: "domain2.foo.com"
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: service3
            port:
              number: 80

Pour pouvoir créer des objets ingress il est d’abord nécessaire d’installer un ingress controller dans le cluster:

  • Il s’agit d’un déploiement conteneurisé d’un logiciel de reverse proxy (comme nginx) et intégré avec l’API de kubernetes
  • Le controlleur agit donc au niveau du protocole HTTP et doit lui-même être exposé (port 80 et 443) à l’extérieur, généralement via un service de type LoadBalancer.
  • Le controleur redirige ensuite vers différents services (généralement configurés en ClusterIP) qui à leur tour redirigent vers différents ports sur les pods selon l’URL de la requête.

Il existe plusieurs variantes d'ingress controller:

  • Un ingress basé sur Nginx plus ou moins officiel à Kubernetes et très utilisé: https://kubernetes.github.io/ingress-nginx/
  • Un ingress Traefik optimisé pour k8s.
  • il en existe d’autres : celui de payant l’entreprise Nginx, Contour, HAProxy…

Chaque provider de cloud et flavour de kubernetes est légèrement différent au niveau de la configuration du controlleur ce qui peut être déroutant au départ:

  • minikube permet d’activer l’ingress nginx simplement
  • autre example: k3s est fourni avec traefik configuré par défaut
  • On peut installer plusieurs ingress controllers correspondant à plusieurs IngressClasses

Comparaison des controlleurs: https://medium.com/flant-com/comparing-ingress-controllers-for-kubernetes-9b397483b46b

Gestion dynamique des certificats à l’aide de certmanager

Certmanager est une application kubernetes (un operator) plus ou moins officielle capable de générer automatiquement des certificats TLS/HTTPS pour nos ingresses.

Exemple de syntaxe d’un ingress utilisant certmanager:

apiVersion: networking.k8s.io/v1 
kind: Ingress
metadata:
  name: kuard
  annotations:
    kubernetes.io/ingress.class: "nginx"    
    cert-manager.io/issuer: "letsencrypt-prod"
spec:
  tls:
  - hosts:
    - example.example.com
    secretName: quickstart-example-tls
  rules:
  - host: example.example.com
    http:
      paths:
      - path: /
        pathType: Exact
        backend:
          service:
            name: kuard
            port:
              number: 80

Le mesh networking et les service meshes

Un service mesh est un type d’outil réseau pour connecter un ensemble de pods, généralement les parties d’une application microservices de façon encore plus intégrée que ne le permet Kubernetes.

En effet opérer une application composée de nombreux services fortement couplés discutant sur le réseau implique des besoins particuliers en terme de routage des requêtes, sécurité et monitoring qui nécessite l’installation d’outils fortement dynamique autour des nos conteneurs.

Un exemple de service mesh est https://istio.io qui, en ajoutant en conteneur “sidecar” à chacun des pods à supervisés, ajoute à notre application microservice un ensemble de fonctionnalités d’intégration très puissant.

CNI (container network interface) : Les implémentations du réseau Kubernetes

Beaucoup de solutions de réseau qui se concurrencent, demandant un comparatif un peu fastidieux.

  • plusieurs solutions très robustes
  • diffèrent sur l’implémentation : BGP, réseau overlay ou non (encapsulation VXLAN, IPinIP, autre)
  • toutes ne permettent pas d’appliquer des NetworkPolicies : l’isolement et la sécurité réseau
  • peuvent parfois s’hybrider entre elles (Canal = Calico + Flannel)
  • ces implémentations sont souvent concrètement des DaemonSets : des pods qui tournent dans chacun des nodes de Kubernetes

  • Calico, Flannel, Weave ou Cilium sont très employées et souvent proposées en option par les fournisseurs de cloud

  • Cilium a la particularité d’utiliser la technologie eBPF de Linux qui permet une sécurité et une rapidité accrue

Comparaisons :

Les network policies : des firewalls dans le cluster

Crédits Ahmet Alp Balkan

Par défaut, les pods ne sont pas isolés au niveau réseau : ils acceptent le trafic de n’importe quelle source.

Les pods deviennent isolés en ayant une NetworkPolicy qui les sélectionne. Une fois qu’une NetworkPolicy (dans un certain namespace) inclut un pod particulier, ce pod rejettera toutes les connexions qui ne sont pas autorisées par cette NetworkPolicy.

Ressources sur le réseau

Vidéos

Des vidéos assez complètes sur le réseau, faites par Calico :

Sur MetalLB, les autres vidéos de la chaîne sont très bien :

09 - TP 4 - Déployer Wordpress Avec une base de donnée persistante

Déployer Wordpress et MySQL avec du stockage et des Secrets

Nous allons suivre ce tutoriel pas à pas : https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/

Il faut :

  • Créez un projet TP4.
  • Créer la kustomization.yaml avec le générateur de secret.
  • Copier les 2 fichiers dans le projet.
  • Les ajouter comme resources à la kustomization.yaml.

Commentons un peu le contenu des deux fichier mysql-deployment.yaml et wordpress-deployment.yaml.

  • Vérifier que le stockage et le secret ont bien fonctionnés.
  • Exposez et visitez le service avec minikube service wordpress. Faite la configuration de base de wordpress.

Observer le déploiement du secret à l’intérieur des pods

  • Entrez dans le pod de mysql grâce au terminal de Lens.
  • Cherchez la variable d’environnement MYSQL_ROOT_PASSWORD à l’aide des commandes env | grep MYSQL. Le conteneur mysql a utilisé cette variable accessible de lui seul pour se configurer.

Observer le déploiement des autres secrets à l’intérieur du pod

  • Entrez dans le pod de mysql grâce au terminal (kubectl exec -it)
  • Cherchez un fichier de secrets à l’aide des commandes cd /var/lib/secrets et cat. Kubernetes monte certains secrets par défaut dans tous les pods.

(optionnel) Ajout d’une ConfigMap

A l’aide de la page de documentation sur les configmaps et de la documentation, ajoutez une configmap pour monter un fichier dans le conteneur Wordpress.

Observez la persistence

  • Supprimez et recréer les deux déploiements (mais pas le total). En rechargeant le site on constate que les données ont été conservées.

  • Allez observer la section stockage dans Lens. Commentons ensemble.

  • Supprimer tout avec kubectl delete -k .. Que s’est-il passé ? (côté storage)

En l’état les PersistentVolumes générés par la combinaise du PersistentVolumeClaim et de la StorageClass de minikube sont également supprimés en même tant que les PVC. Les données sont donc perdues et au chargement du site on doit relancer l’installation.

Pour éviter cela il faut que la storageClass standard soit configurée avec une Reclaim Policy à retain (conserver) et non delete. Cependant minikube dans docker ne permet pas simplement de faire une storage class en mode retain (à cause d’un bug semble-t-il). Nous allons donc créer manuellement des volumes avec une storageClass retain.

  • Créez deux volumes en cliquant sur le + > create resource en bas à gauche de Lens et collez le code suivant:
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: wordpress-mysql-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 100Mi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/mysql-data"
---
kind: PersistentVolume
apiVersion: v1
metadata:
  name: wordpress-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 100Mi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/wp-data"
  • Modifiez les PersistentVolumeClaims(PVC) des deploiements wordpress et mysql pour passer le storage à 100Mi et ajouter storageClassName: manual dans la spec: de chaque PVC.

  • Recréez les ressources avec apply. Les volumes devraient se connecter à nos conteneurs mysql et wordpress.

Essayons avec Scaleway

10 - Cours - Objets Kubernetes Partie 2.

Le stockage dans Kubernetes

Les Volumes Kubernetes

Comme dans Docker, Kubernetes fournit la possibilité de monter des volumes virtuels dans les conteneurs de nos pod. On liste séparément les volumes de notre pod puis on monte un ou plusieurs points de montage dans les différents conteneurs Exemple:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
spec:
  containers:
  - image: k8s.gcr.io/test-webserver
    name: test-container
    volumeMounts:
    - mountPath: /test
      name: test-volume
  volumes:
  - name: test-volume
    hostPath:
      # chemin du dossier sur l'hôte
      path: /data
      # ce champ est optionnel
      type: Directory

La problématique des volumes et du stockage est plus compliquée dans kubernetes que dans docker car k8s cherche à répondre à de nombreux cas d’usages. doc officielle. Il y a donc de nombeux types de volumes kubernetes correspondants à des usages de base et aux solutions proposées par les principaux fournisseurs de cloud.

Mentionnons quelques d’usage de base des volumes:

  • hostPath: monte un dossier du noeud ou est plannifié le pod à l’intérieur du conteneur.
  • local: comme hostPath mais conscient de la situation physique du volume sur le noeud et à combiner avec les placements de pods avec nodeAffinity
  • emptyDir: un dossier temporaire qui est supprimé en même temps que le pod
  • configMap: pour monter des fichiers de configurations provenant du cluster à l’intérieur des pods
  • secret: pour monter un secret (configuration) provenant du cluster à l’intérieur des pods
  • cephfs: monter un volume ceph provenant d’un ceph installé sur le cluster
  • etc.

En plus de la gestion manuelle des volumes avec les option précédentes, kubernetes permet de provisionner dynamiquement du stockage en utilisant des plugins de création de volume grâce à 3 types d’objets: StorageClass PersistentVolume et PersistentVolumeClaim.

Les types de stockage avec les StorageClasses

Le stockage dynamique dans Kubernetes est fourni à travers des types de stockage appelés StorageClasses :

  • dans le cloud, ce sont les différentes offres de volumes du fournisseur,
  • dans un cluster auto-hébergé c’est par exemple des opérateurs de stockage comme rook.io ou longhorn(Rancher).

doc officielle

Demander des volumes et les liers aux pods :PersistentVolumes et PersistentVolumeClaims

Quand un conteneur a besoin d’un volume, il crée une PersistentVolumeClaim : une demande de volume (persistant). Si un des objets StorageClass est en capacité de le fournir, alors un PersistentVolume est créé et lié à ce conteneur : il devient disponible en tant que volume monté dans le conteneur.

  • les StorageClasses fournissent du stockage
  • les conteneurs demandent du volume avec les PersistentVolumeClaims
  • les StorageClasses répondent aux PersistentVolumeClaims en créant des objets PersistentVolumes : le conteneur peut accéder à son volume.

doc officielle

Le provisionning de volume peut être manuelle (on crée un objet PersistentVolume ou non la PersistentVolumeClaim mène directement à la création d’un volume persistant si possible)

Des déploiements plus stables et précautionneux : les StatefulSets

L’objet StatefulSet est relativement récent dans Kubernetes.

On utilise les Statefulsets pour répliquer un ensemble de pods dont l’état est important : par exemple, des pods dont le rôle est d’être une base de données, manipulant des données sur un disque.

Un objet StatefulSet représente un ensemble de pods dotés d’identités uniques et de noms d’hôtes stables. Quand on supprime un StatefulSet, par défaut les volumes liés ne sont pas supprimés.

Les StatefulSets utilisent un nom en commun suivi de numéros qui se suivent. Par exemple, un StatefulSet nommé web comporte des pods nommés web-0, web-1 et web-2. Par défaut, les pods StatefulSet sont déployés dans l’ordre et arrêtés dans l’ordre inverse (web-2, web-1 puis web-0).

En général, on utilise des StatefulSets quand on veut :

  • des identifiants réseau stables et uniques
  • du stockage stable et persistant
  • des déploiements et du scaling contrôlés et dans un ordre défini
  • des rolling updates dans un ordre défini et automatisées

Article récapitulatif des fonctionnalités de base pour applications stateful: https://medium.com/capital-one-tech/conquering-statefulness-on-kubernetes-26336d5f4f17

Paramétrer ses Pods

Les ConfigMaps

D’après les recommandations de développement 12factor, la configuration de nos programmes doit venir de l’environnement. L’environnement est ici Kubernetes.

Les objets ConfigMaps permettent d’injecter dans des pods des ensemble clés/valeur de configuration en tant que volumes/fichiers de configuration ou variables d’environnement.

les Secrets

Les Secrets se manipulent comme des objets ConfigMaps, mais ils sont chiffrés et faits pour stocker des mots de passe, des clés privées, des certificats, des tokens, ou tout autre élément de config dont la confidentialité doit être préservée. Un secret se créé avec l’API Kubernetes, puis c’est au pod de demander à y avoir accès.

Il y a 3 façons de donner un accès à un secret :

  • le secret est un fichier que l’on monte en tant que volume dans un conteneur (pas nécessairement disponible à l’ensemble du pod). Il est possible de ne jamais écrire ce secret sur le disque (volume tmpfs).
  • le secret est une variable d’environnement du conteneur.

Pour définir qui et quelle app a accès à quel secret, on peut utiliser les fonctionnalités “RBAC” de Kubernetes.

Lier utilisateurs et autorisations: Le Role-Based Access Control (RBAC)

Kubernetes intègre depuis quelques versions un système de permissions fines sur les ressources et les namespaces. Il fonctionne en liant des ensembles de permissions appelées Roles à des identités/comptes humains appelés User ou des comptes de services pour vos programmes appelés ServiceAccount.

Exemple de comment générer un certificat à créer un nouvel utilisateur dans minikube: https://docs.bitnami.com/tutorials/configure-rbac-in-your-kubernetes-cluster/

Roles et ClusterRoles + bindings

Une role est un objet qui décrit un ensemble d’actions permises sur certaines ressources et s’applique sur un seul namespace. Pour prendre un exemple concret, voici la description d’un roles qui authorise la lecture, création et modification de pods et de services dans le namespace par défaut:

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: default
  name: pod-and-services
rules:
- apiGroups: [""]
  resources: ["pods", "services"]
  verbs: ["create", "delete", "get", "list", "patch", "update", "watch", "proxy"]
  • Un role est une liste de règles rules

  • Les rules sont décrites à l’aide de 8 verbes différents qui sont ceux présent dans le role d’exemple au dessus qu’ont associe à une liste d’objets.

  • Le role ne fait rien par lui même : il doit être appliqué à une identité ie un User ou ServiceAccount.

  • Classiquement on crée des Roles comme admin ou monitoring qui désignent un ensemble de permission consistante pour une tâche donnée.

  • Notre rôle exemple est limité au namespace default. Pour créer des permissions valable pour tout le cluster on utilise à la place un objet appelé un ClusterRole qui fonctionne de la même façon mais indépendamment des namespace.

  • Les Roles et ClusterRoles sont ensuite appliqués aux ServicesAccounts à l’aide respectivement de RoleBinding et ClusterRoleBinding comme l’exemple suivant:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  namespace: default
  name: pods-and-services
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: alice
- apiGroup: rbac.authorization.k8s.io
  kind: Group
  name: mydevs
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: pod-and-services

En plus des rôles que vous pouvez créer pour les utilisateur·ices et processus de votre cluster, il existe déjà dans kubernetes un ensemble de ClusterRoles prédéfinis qui sont affichables avec :

kubectl get clusterroles

La plupart de ces rôles intégrés sont destinés au kube-system, c’est-à-dire aux processus internes du cluster.

Cependant quatre rôles génériques existent aussi par défaut :

  • Le rôle cluster-admin fournit un accès complet à l’ensemble du cluster.
  • Le rôle admin fournit un accès complet à un espace de noms précis.
  • Le rôle edit permet à un·e utilisateur·ice de modifier des choses dans un espace de noms.
  • Le rôle view permet l’accès en lecture seule à un espace de noms.

La commande kubectl auth can-i <verb> <type_de_resource> permet de déterminer selon le profil utilisé (défini dans votre kubeconfig) les permissions actuelles de l’user sur les objets Kubernetes.

11 - Cours - Helm, le gestionnaire de paquets Kubernetes et les Opérateurs

Nous avons vu que dans Kubernetes la configuration de nos services / applications se fait généralement via de multiples fichiers YAML.

Les kustomizations permettent de rassembler ces descriptions en dossier de code et ont pas mal d’avantages mais on a vite besoin de quelque chose de plus puissant.

  • Pour s’adapter à plein de paramétrages différents de notre application
  • Pour éviter la répétition de code

C’est donc “trop” déclaratif en quelque sorte, et il faut se concentrer sur les quelques propriétés que l’on souhaite créer ou modifier,

Helm

Pour pallier ce problème, il existe un utilitaire appelé Helm, qui produit les fichiers de déploiement que l’on souhaite.

Helm est le package manager recommandé par Kubernetes, il utilise les fonctionnalités de templating du langage Go.

Helm permet donc de déployer des applications / stacks complètes en utilisant un système de templating et de dépendances, ce qui permet d’éviter la duplication et d’avoir ainsi une arborescence cohérente pour nos fichiers de configuration.

Mais Helm propose également :

  • la possibilité de mettre les Charts dans un répertoire distant (Git, disque local ou partagé…), et donc de distribuer ces Charts publiquement.
  • un système facilitant les Updates et Rollbacks de vos applications.

Il existe des sortes de stores d’applications Kubernetes packagées avec Helm, le plus gros d’entre eux est Kubeapps Hub, maintenu par l’entreprise Bitnami qui fournit de nombreuses Charts assez robustes.

Si vous connaissez Ansible, un chart Helm est un peu l’équivalent d’un rôle Ansible dans l’écosystème Kubernetes.

Concepts

Les quelques concepts centraux de Helm :

  • Un package Kubernetes est appelé Chart dans Helm.

  • Un Chart contient un lot d’informations nécessaires pour créer une application Kubernetes :

    • la Config contient les informations dynamiques concernant la configuration d’une Chart
    • Une Release est une instance existante sur le cluster, combinée avec une Config spécifique.

Quelques commandes Helm:

Voici quelques commandes de bases pour Helm :

  • helm repo add bitnami https://charts.bitnami.com/bitnami: ajouter un repo contenant des charts

  • helm search repo bitnami : rechercher un chart en particulier

  • helm install my-release my-chart --values=myvalues.yaml : permet d’installer le chart my-chart avec le nom my-release et les valeurs de variable contenues dans myvalues.yaml (elles écrasent les variables par défaut)

  • helm upgrade my-release my-chart : permet de mettre à jour notre release avec une nouvelle version.

  • helm ls: Permet de lister les Charts installés sur votre Cluster

  • helm delete my-release: Permet de désinstaller la release my-release de Kubernetes

La configuration d’un Chart: des templates d’objets Kubernetes

Visitons un exemple de Chart : minecraft

On constate que Helm rassemble des fichiers de descriptions d’objets k8s avec des variables (moteur de templates de Go) à l’intérieur, ce qui permet de factoriser le code et de gérer puissamment la différence entre les versions.

Kubernetes API et extension par APIgroups

Tous les types de resources Kubernetes correspondent à un morceau (un sous arbre) d’API REST de Kubernetes. Ces chemins d’API pour chaque ressources sont classés par groupe qu’on appelle des apiGroups:

  • On peut lister les resources et leur groupes d’API avec la commande kubectl api-resources -o wide.
  • Ces groups correspondent aux préfixes indiqué dans la section apiVersion des descriptions de ressources.
  • Ces groupes d’API sont versionnés sémantiquement et classés en alpha beta et stable. beta indique déjà un bon niveau de stabilité et d’utilisabilité et beaucoup de ressources officielles de kubernetes ne sont pas encore en api stable. Exemple: les CronJobs viennent de se stabiliser au début 2021.
  • N’importe qui peut développer ses propres types de resources appelées CustomResourceDefinition (voir ci dessous) et créer un apiGroup pour les ranger.

Documentation: https://kubernetes.io/docs/reference/using-api/

Operators et Custom Resources Definitions (CRD)

Un opérateur est :

  • un morceau de logique opérationnelle de votre infrastructure (par exemple: la mise à jour votre logiciel de base de donnée stateful comme cassandra ou elasticsearch) …
  • … implémenté dans kubernetes par un/plusieurs conteneur(s) “controller” …
  • … controllé grâce à une extension de l’API Kubernetes sous forme de nouveaux type d’objets kubernetes personnalisés (de haut niveau) appelés CustomResourcesDefinition
  • … qui crée et supprime des resources de base Kubernetes comme résultat concrêt.

Les opérateurs sont un sujet le plus méta de Kubernetes et sont très à la mode depuis leur démocratisation par Red Hat pour la gestion automatique de base de données.

  • Il peuvent être développés avec un framework Go ou Ansible
  • Ils sont généralement répertoriés sur le site: https://operatorhub.io/

Exemples :

  • L’opérateur Prometheus permet d’automatiser le monitoring d’un cluster et ses opérations de maintenance.
  • la chart officielle de la suite Elastic (ELK) définit des objets de type elasticsearch
  • KubeVirt permet de rajouter des objets de type VM pour les piloter depuis Kubernetes
  • Azure propose des objets correspondant à ses ressources du cloud Azure, pour pouvoir créer et paramétrer des ressources Azure directement via la logique de Kubernetes.

Limites des opérateurs

Il est possible de développer soit même des opérateurs mais il s’agit de développement complexes qui devraient être entrepris par les développeurs du logiciel et qui sont surtout utiles pour des applications distribuées et stateful. Les opérateurs n’ont pas forcément vocation à remplacer les Charts Helm comme on l’entend parfois.

Voir : https://thenewstack.io/kubernetes-when-to-use-and-when-to-avoid-the-operator-pattern/

12 - TP 5 - Déployer Wordpress avec Helm et ArgoCD

Helm est un “gestionnaire de paquet” ou vu autrement un “outil de templating avancé” pour k8s qui permet d’installer des applications sans faire des copier-coller pénibles de YAML :

  • Pas de duplication de code
  • Possibilité de créer du code générique et flexible avec pleins de paramètres pour le déploiement.
  • Des déploiements avancés avec plusieurs étapes

Inconvénient: Helm ajoute souvent de la complexité non nécessaire car les Charts sur internet sont très paramétrables pour de multiples cas d’usages (plein de code qui n’est utile que dans des situations spécifiques).

Helm ne dispense pas de maîtriser l’administration de son cluster.

Installer Helm

  • Pour installer Helm sur Ubuntu, utilisez : sudo snap install helm --classic

Autocomplete

helm completion bash | sudo tee /etc/bash_completion.d/helm et relancez votre terminal.

Utiliser un chart Helm pour installer Wordpress

  • Cherchez Wordpress sur https://artifacthub.io/.

  • Prenez la version de Bitnami et ajoutez le dépôt avec la commande indiquée dans “Install” : helm repo add bitnami https://charts.bitnami.com/bitnami

  • Installer une “release” wordpress-tp de cette application (ce chart) avec helm install wordpress-tp bitnami/wordpress

  • Suivez les instructions affichées dans le terminal pour trouver l’IP et afficher le login et password de notre installation. Si l’IP n’est pas accessible, il faut également lancer kubectl port-foward service wordpress-tp <port_de_votre_choix>:80.

  • Notre Wordpress est prêt. Connectez-vous-y avec les identifiants affichés (il faut passer les commandes indiquées pour récupérer le mot de passe stocké dans un secret k8s).

Vous pouvez constater que l’objet Service est par default Loadbalancer ce qui n’est pas très pertinent. Un chart prend de nombreux paramètres de configuration qui sont toujours listés dans le fichier values.yaml à la racine du Chart.

On peut écraser certains de ces paramètres dans un nouveau fichier par exemple myvalues.yaml et installer la release avec l’option --values=myvalues.yaml.

  • Désinstallez Wordpress avec helm uninstall wordpress-tp

Utiliser la fonction template de Helm pour étudier les ressources d’un Chart

  • Comment modifier l’username wordpress à l’installation ? il faut donner comme paramètres le yaml suivant:
wordpressUsername: <votrenom>
  • Nous allons paramétrer plus encore l’installation. Créez un dossier TP5 avec à l’intérieur un fichier values.yaml contenant:
wordpressUsername: <stagiaire> # replace
wordpressBlogName: Kubernetes example blog

replicaCount: 1

service:
  type: ClusterIP

ingress:
  enabled: true
  ingressClassName: nginx
  hostname: wordpress.<stagiaire>.formation.dopl.uk # replace with your hostname pointing on the cluster ingress loadbalancer IP

Si vous avez activé certmanager (voir TP optionnel) vous pouvez remplacer la clé ingress avec :


ingress:
  enabled: true
  hostname: wordpress.<stagiaire>.formation.dopl.uk # replace with your hostname pointing on the cluster ingress loadbalancer IP
  tls: true
  certManager: true
  ingressClassName: nginx
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    kubernetes.io/ingress.class: nginx
  • En utilisant ces paramètres, plutôt que d’installer le chart, nous allons faire le rendu (templating) des fichiers ressource générés par le chart: helm template wordpress-tp bitnami/wordpress --values=values.yaml > wordpress-tp-manifests.yaml.

On peut maintenant lire dans ce fichier les objets kubernetes déployés par le chart et ainsi apprendre de nouvelles techniques et syntaxes. En le parcourant on peut constater que la plupart des objets abordés pendant cette formation y sont présent plus certains autres.

Créer sa chart Helm

  • Visitez le code des charts de votre choix en clonant le répertoire Git des Charts officielles Bitnami et en l’explorant avec VSCode :
git clone https://github.com/bitnami/charts/ --depth 1
code charts/bitnami/wordpress
  • Regardez en particulier les fichiers templates et le fichier de paramètres values.yaml.

Installer ArgoCD

Voir le TP Gitlab et ArgoCD.

Facultatif : A la main, avec MySQL, des init containers et des ConfigMaps

TP optionnel - Exposer une application en HTTPS via certmanager et un ingress nginx

  1. Installer cert-manager avec la commande kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.6.1/cert-manager.yaml

Créer un certificat Letsencrypt pour notre cluster k3s: version Traefik

  1. Objet de type ClusterIssuer à créer pour configurer Let’s Encrypt :
apiVersion: cert-manager.io/v1alpha2
kind: ClusterIssuer
metadata:
  #   name: letsencrypt-staging
  name: letsencrypt-prod
spec:
  acme:
    email: cto@doxx.fr
    privateKeySecretRef:
      name: prod-issuer-account-key
    #   name: staging-issuer-account-key
    server: https://acme-v02.api.letsencrypt.org/directory
    # server: https://acme-staging-v02.api.letsencrypt.org/directory
    http01: {}
    solvers:
      - http01:
          ingress:
            class: traefik
        selector: {}
  1. Si ce n’est pas fait, installer un Ingress Controller (un reverse proxy) avec Helm, ici nous installons Traefik mais ça peut être Nginx (si vous prenez Nginx, il faudra modifier un peu l’objet Ingress plus bas et l’avant-dernière ligne de l’objet ClusterIssuer) :
helm repo add traefik https://helm.traefik.io/traefik
helm repo update
helm install traefik traefik/traefik
  1. Créer un objet Ingress en adaptant celui donné dans le tutoriel (il faudra qu’il soit lié à un Service existant, lui-même lié à un objet Deployment existant) :
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: monster-ingress
  annotations:
    traefik.ingress.kubernetes.io/router.tls: "true"
    kubernetes.io/ingress.class: traefik
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
    - hosts:
        - monster.hadrien.lab.doxx.fr
      secretName: monster-hadrien-lab-doxx-fr
  rules:
    - host: monster.hadrien.lab.doxx.fr
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: monstericon
                port:
                  number: 5000

NB : si vous n’arrivez pas à obtenir de certificat HTTPS, modifiez l’objet ClusterIssuer pour obtenir un certificat depuis les serveurs staging de Let’s Encrypt : Let’s Encrypt limite très fortement le nombre de certificats installables sur les mêmes domaines et sous-domaines.

Créer un certificat Letsencrypt pour notre cluster k3s: version Nginx

TP opt. - Le RBAC

Les rôles et le RBAC

  1. Configurer Minikube pour activer RBAC.
minikube start --extra-config=apiserver.Authorization.Mode=RBAC

kubectl create clusterrolebinding add-on-cluster-admin --clusterrole=cluster-admin --serviceaccount=kube-system:default
  1. Créer trois connexions à minikube dans ~/.kube/config :
  • une en mode cluster-admin,
  • une en mode admin sur un namespace
  • et une en mode user avec un rolebinding
  1. En switchant de contexte à chaque fois, lancer la commande kubectl auth can-i pour différents cas et observer la différence

Ressources

TP optionnel - Installer un registry privé d'images dans votre cluster

https://www.linuxtechi.com/setup-private-docker-registry-kubernetes/

Pour une solution plus avancée que le simple conteneur registry voir par exemple:

-> le registry gitlab (sur gitlab.com ou on premise) -> https://goharbor.io/ -> registry avancé avec analyse de vulnérabilité des images

TP opt. - CI/CD avec Gitlab et ArgoCD

Installation d’un cluster avec argoCD

ArgoCD est un outil de GitOps extrêment pratique et puissant mais il nécessite d’être installé dans un cluster public (avec un IP publique) et avec un certificat HTTPS pour être utilisé correctement.

Qu’est-ce que le GitOps: https://www.objectif-libre.com/fr/blog/2019/12/17/gitops-tour-horizon-pratiques-outils/

Vos serveurs VNC qui sont aussi désormais des clusters k3s ont déjà plusieurs sous-domaines configurés: <votrelogin>.<sousdomaine>.dopl.uk et *.<votrelogin>.<sousdomaine>.dopl.uk. Le sous domaine argocd.<login>.<sousdomaine>.dopl.uk pointe donc déjà sur le serveur (Wildcard DNS).

Ce nom de domaine va nous permettre de générer un certificat HTTPS pour notre application web argoCD grâce à un ingress nginx, le cert-manager de k8s et letsencrypt (challenge HTTP101).

Installer le ingress NGINX dans k3s

  • Installer l’ingress nginx avec la commande: kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.0/deploy/static/provider/cloud/deploy.yaml (pour autres méthodes ou problèmes voir : https://kubernetes.github.io/ingress-nginx/deploy/)

  • Vérifiez l’installation avec kubectl get svc -n ingress-nginx ingress-nginx-controller : le service ingress-nginx-controller devrait avoir une IP externe.

Installer Cert-manager dans k3s

  • Pour installer cert-manager lancez : kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.6.1/cert-manager.yaml

  • Il faut maintenant créer une ressource de type ClusterIssuer pour pourvoir émettre (to issue) des certificats.

  • Créez une ressource comme suit (soit dans Lens avec + soit dans un fichier à appliquer ensuite avec kubectl apply -f):

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    # You must replace this email address with your own.
    # Let's Encrypt will use this to contact you about expiring
    # certificates, and issues related to your account.
    email: cto@doxx.fr
    server: https://acme-v02.api.letsencrypt.org/directory
    privateKeySecretRef:
      # Secret resource that will be used to store the account's private key.
      name: letsencrypt-prod-account-key
    # Add a single challenge solver, HTTP01 using nginx
    solvers:
    - http01:
        ingress:
          class: nginx

Installer Argocd

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: argocd-server-ingress
  namespace: argocd
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    # If you encounter a redirect loop or are getting a 307 response code 
    # then you need to force the nginx ingress to connect to the backend using HTTPS.
    #
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  tls:
  - hosts:
    - argocd.<yoursubdomain>
    secretName: argocd-secret # do not change, this is provided by Argo CD
  rules:
  - host: argocd.<yoursubdomain>
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: argocd-server
            port:
              number: 443
  • Créez et appliquez cette ressource Ingress.

  • Vérifiez dans Lens que l’ingress a bien généré un certificat (cela peut prendre jusqu’à 2 minutes)

  • Chargez la page argocd.<votre sous domaine> dans un navigateur. exp argocd.stagiaire1.docker.dopl.uk

  • Pour se connecter utilisez le login admin et récupérez le mot de passe admin en allant chercher le secret argocd-initial-admin-secret dans Lens (Config > Secrets avec le namespace argocd activé).

Récupérer le corrigé du TP et le pousser sur Gitlab

  • Récupérer le corrigé à compléter du TP CICD gitlab argocd avec git clone -b k8s_gitlab_argocd_correction https://github.com/Uptime-Formation/corrections_tp.git k8s_gitlab_argocd_correction

  • Ouvrez le projet dans VSCode

  • Créer un nouveau projet vide sur gitlab

  • Remplacez dans tout le projet, les occurences de <sousdomain>.dopl.uk par votre sous domaine par exemple stagiaire1.docker.dopl.uk

  • Remplacez également partout gitlab.com/e-lie/cicd_gitlab_argocd_corrections par l’url de votre dépot Gitlab (sans le https:// ou git@).

  • Poussez ce projet dans la branche k8s_gitlab_argocd_correction du dépot créé précédement:

git remote add gitlab <votre dépot gitlab>
git push gitlab
  • Observons le fichier .gitlab-ci.yml.

  • Allons voir le pipeline dans l’interface CI/CD de gitlab. Les deux premier stages du pipeline devraient s’être bien déroulés.

Déploiement de l’application dans argoCD

Expliquons un peu le reste du projet projet.

  • Créez un token de déploiement dans Gitlab > Settings > Repository > Deploy Tokens. Ce token va nous permettre de donner l’authorisation à ArgoCD de lire le dépôt gitlab (facultatif si le dépôt est public cela ne devrait pas être nécessaire). Complétez ensuite 2 fois le token dans le fichier k8s/argocd-apps.yaml comme suit : https://<nom_token>:<motdepasse_token>@gitlab.com/<votre depo>.git dans les deux sections repoURL: des deux applications.

  • Créer les deux applications monstericon-dev et monstericon-prod dans argocd avec kubectl apply -f k8s/argocd-apps.yaml.

  • Allons voir dans l’interface d’ArgoCD pour vérifier que les applications se déploient bien sauf le conteneur monstericon dont l’image n’a pas encore été buildée avec le bon tag. Pour cela il va falloir que notre pipeline s’execute complètement.

Les deux étapes de déploiement (dev et prod) du pipeline nécessitent de pousser automatiquement le code du projet à nouveau pour déclencher le redéploiement automatique dans ArgoCD (en mode pull depuis gitlab). Pour cela nous avons besoin de créer également un token utilisateur:

  • Allez dans Gitlab > User Settings (en haut à droite dans votre profil) > Access Tokens et créer un token avec read_repository write_repository read_registry write_registry activés. Sauvegardez le token dans un fichier.

  • Allez dans Gitlab > Settings > CI/CD > Variables pour créer deux variables de pipelines: CI_USERNAME contenant votre nom d’utilisateur gitlab et CI_PUSH_TOKEN contenant le token précédent. Ces variables de pipelines nous permettent de garder le token secret dans gitlab et de l’ajouter automatiquement aux pipeline pour pouvoir autoriser la connexion au dépot depuis le pipeline (git push).

  • Nous allons maintenant tester si le pipeline s’exécute correctement en commitant et poussant à nouveau le code avec git push gitlab.

  • Debuggons les pipelines s’ils sont en échec.

  • Allons voir dans ArgoCD pour voir si l’application dev a été déployée correctement. Regardez la section events et logs des pods si nécessaire.

  • Une fois l’application dev complètement healthy (des coeurs verts partout). On peut visiter l’application en mode dev à l’adresse https://monster-dev.<votre_sous_domaine>.

  • On peut ensuite déclencer le stage deploy-prod manuellement dans le pipeline, vérifier que l’application est healthy dans ArgoCD (debugger sinon) puis visiter https://monster.<votre_sous_domaine>.

Idées d’amélioration

  • Déplacer le code de déploiement dans un autre dépôt que le code d’infrastructure. Le pipeline de devra cloner le dépôt d’infrastructure, templater avec kustomize la bonne version de l’image dans le bon environnement. Pousser le code d’infrastructure sur le dépôt d’infrastructure. Corriger l’application ArgoCD pour monitorer le dépôt d’infrastructure.

  • Mutualiser le code de déploiement k8s avec des overlays kustomize

  • Utiliser une stragégie de blue/green ou A/B déploiement avec Argo Rollouts ou Istio avec vérification de réussite du déploiement et rollback en cas d’échec.

  • Ajouter plus d’étapes réalistes de CI/CD en se basant par exemple sur le livre GitOps suivant.

  • Gérer la création des ressources gitlab automatiquement avec Terraform et gérer les secrets (tokens gitlab) consciencieusement.

Bibliographie

  • 2021 - GitOps and Kubernetes Continuous Deployment with Argo CD, Jenkins X, and Flux

  • Billy Yuen, Alexander Matyushentsev, Todd Ekenstam, Jesse Suen (z-lib.org)

Bibliographie

Livres

Chez oreilly:

  • Cloud Native DevOps with Kubernetes (la philosophie et les enjeux du choix de kubernetes avec des exemples techniques)
  • Kubernetes Up and Running (les bases mais déjà compliqué)
  • Kubernetes Best Practices (problématiques avancés et bonnes pratiques de résolution)

Ressources

Réseau

Vidéos sur le réseau

Des vidéos assez complètes sur le réseau, faites par Calico :

Sur MetalLB, les autres vidéos de la chaîne sont très bien :

Stockage

Sécurité de Kubernetes

Gestion de secrets

TODO

2 TP de plus sur K8S pur : secrets + RBAC non ? PVC et storage classes, daemonset… (postgres avec helm ?), HPA ?

1 TP sur Azure (registries ? l’app cheloue ? Terraform ?) + les TP prémâchés de la doc Azure

1 TP plus dev ? TP Docker surtout

  • imprimer des tas de schémas et de fiches plastifiées sur les concepts de k8s (idéalement qui “s’emboîtent” façon puzzle) et les distribuer dès le début, recréer les chémas avec ça au tableau

TP registry : https://www.linuxtechi.com/setup-private-docker-registry-kubernetes/

  • Faire du docker ?
  • Faire une intro à K8S en commençant par Docker swarm ?
  • Intro DevOps
  • Rappels YAML

Idées TP

  • rbac
  • multinode avec terraform (ou k3sup ?), ou simplement https://microk8s.io/docs/clustering ?
  • gestion des secrets
  • gestion des configmaps
  • storageclasses
  • ingresses
  • horizontal pod autoscaling avec montée en charge
  • daemonsets
  • statefulsets (chart postgres ?)

Notes en vrac

  • Kubernetes + Rancher
    • Concepts K8S
    • petites manips avec docker run rancher et rancher utilisé comme IDE pour du déploiement k8s, GUI k8s
    • chart helm
    • déployer une CI en mettant non seulement gitlab dans k8s mais aussi utiliser un node comme CI
    • rancher intro à la logique : problématiques de PaaS, cloud hybride / multi cluster et workloads + multi cluster apps (enhanced helm w/ rancher), auth et multiuser (RBAC)
    • ouverture vers pbmatiques réseau distribués (canal/flannel/calico/istio) et volume distribué (ceph/gluster), debug des accès disque et réseau avec truc de tracing poussé par rancher jaeger

Ressources K8S

Cours

Bouquin Learn openshift très cool

TP

https://github.com/GoogleCloudPlatform/kubernetes-workshops

General

Sécurité K8S

super tp pour sécuriser la stack elastic sur k8s avec cilium : http://docs.cilium.io/en/stable/gettingstarted/elasticsearch/

Ressources K8S

https://codelabs.developers.google.com/codelabs/cloud-orchestrate-with-kubernetes/#0

TP

Gitlab

https://medium.com/@abenahmed1/pipeline-de-ci-cd-simplifi%C3%A9-dans-un-cluster-kubernetes-avec-gitlab-et-rancher-602a01029bae

Il y a aussi Rancher’s own CI/CD pipeline: https://rancher.com/docs/rancher/v2.x/en/project-admin/pipelines/

NOTE: Gitlab operator? https://docs.gitlab.com/charts/installation/operator.html

Rancher

Idées TD :


TD idées

https://github.com/GoogleCloudPlatform/kubernetes-workshops/tree/master/state https://github.com/GoogleCloudPlatform/kubernetes-workshops/tree/master/advanced et https://github.com/GoogleCloudPlatform/kubernetes-workshops/blob/master/advanced/local.md


Apps de demo

https://github.com/oskapt/rancher-demo

Ressources

(https://www.mirantis.com/blog/multi-container-pods-and-container-communication-in-kubernetes/).

https://github.com/cyberark/KubiScan

https://github.com/ramitsurana/awesome-kubernetes/blob/master/docs/managed-kubernetes/managed-kubernetes.md

Azure Terraform

az ad sp create-for-rbac –skip-assignment

https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/guides/service_principal_client_secret https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs https://docs.microsoft.com/fr-fr/azure/developer/terraform/get-started-cloud-shell#authenticate-via-azure-service-principal

TP

Un tp dockerfile to registry to running?

https://www.katacoda.com/courses/kubernetes/deploy-service-from-source

Demo app

https://github.com/instana/robot-shop https://github.com/microservices-demo/microservices-demo/tree/master/deploy/kubernetes/helm-chart/templates

Notes

Todo: parler de ce que devrait fait une CD de Gitlab : se connecter à un bastion, git pull, puis kubectl apply

TODO: add commandes pour basculer de namespace, le créer et l’ajouter dans son kubeconfig

TODO: Inglressa vec dns ou joli minikube (jour 2)

TODO: Jour 1 kustomization + secrets + liveness et eventuellement configmaps

TODO: –watch

TODO/ livenessprobe mysql TODO: readinessprobe avec podinfo ou l’app python qui se kill + readiness probe type exec + initcontainer

clusterip: none?

TODO: Ressource et cours should u microservices (et bonnes pratiquesde dockernetrypoint qui reboot) et should u crd +

TODO: paradigme k8s de pas orchestrer mais chaos, a ses limites (ajotus statefulsets)

TODO: Purge sensible tp from git

TODO: Ajout initcontainers : https://kubernetes.io/fr/docs/concepts/workloads/pods/init-containers/

TODO: clarifier specs pods et deployments, clarifier accès aux specs

TODO: artifacthub

TODO: gros tp de helm avec postgres ha, wiki, blog, registry, monstersstack et even gitlab avec runner ??, et les ingresses qui vont bien

TODO: tuto bkpr

TODO: tuto registry as helm: harbour, docker-registry, else?

TODO: tuto helm cert manager / lego / let’s encrypt

TODO: parler des retours d’expérience de mise en place de k8s grâce aux pages là dessus dans la doc de k8s

Ajouter dans kubeconfig Parler des namespaces dans les contexts

ne pas parler de réseau 2 fois

strategy: recreate bof pour demo, mais sinon rollingupdate est default


  • istio et networkpolicies ?

  • k3s multi node ?

  • argocd ?

  • chart Helm ?

  • rancher ?

  • depuis Pod jusqu’à Deployment ? oui !

  • metalLB ou au moins TP d’ingress avec HTTPS (cert-manager) jusqu’au bout ? oui

  • package docker à k8s avec machin ? skaffoold

  • partie réseau

  • solution de volume décentralisé ? contrainte à nndoe -> stockage ici ? bases de storageclasses

  • réseau vidéo

  • bien comprendre bases


  • rancher demo avec vaches rouges et bleues en 2 deployments mais un seul service

TP optionnel - Stratégies de déploiement et monitoring

Installer Prometheus pour monitorer le cluster Minikube

Pour comprendre les stratégies de déploiement et mise à jour d’application dans Kubernetes (deployment and rollout strategies) nous allons installer puis mettre à jour une application d’exemple et observer comment sont gérées les requêtes vers notre application en fonction de la stratégie de déploiement choisie.

Pour cette observation on peut utiliser un outil de monitoring. Nous utiliserons ce TP comme prétexte pour installer une des stack les plus populaires et intégrée avec kubernetes : Prometheus et Grafana. Prometheus est un projet de la Cloud Native Computing Foundation.

Prometheus est un serveur de métriques c’est à dire qu’il enregistre des informations précises (de petite taille) sur différents aspects d’un système informatique et ce de façon périodique en effectuant généralement des requêtes vers les composants du système (metrics scraping).

Installer Prometheus avec Helm

Installez Helm si ce n’est pas déjà fait. Sur Ubuntu : sudo snap install helm --classic

  • Créons un namespace pour prometheus et grafana : kubectl create namespace monitoring

  • Ajoutez le dépot de chart Prometheus et kube-state-metrics: helm repo add prometheus-community https://prometheus-community.github.io/helm-charts puis helm repo add kube-state-metrics https://kubernetes.github.io/kube-state-metrics puis mise à jours des dépots helm helm repo update.

  • Installez ensuite le chart prometheus :

helm install \
  --namespace=monitoring \
  --version=13.2.1 \
  --set=service.type=NodePort \
  prometheus \
  prometheus-community/prometheus

kube-state-metrics et le monitoring du cluster

Le chart officiel installe par défaut en plus de Prometheus, kube-state-metrics qui est une intégration automatique de kubernetes et prometheus.

Une fois le chart installé vous pouvez visualisez les informations dans Lens, dans la premiere section du menu de gauche Cluster.

Déployer notre application d’exemple (goprom) et la connecter à prometheus

Nous allons installer une petite application d’exemple en go.

  • Téléchargez le code de l’application et de son déploiement depuis github: git clone https://github.com/e-lie/k8s-deployment-strategies

Nous allons d’abord construire l’image docker de l’application à partir des sources. Cette image doit être stockée dans le registry de minikube pour pouvoir être ensuite déployée dans le cluster. En mode développement Minikube s’interface de façon très fluide avec la ligne de commande Docker grace à quelques variable d’environnement : minikube docker-env

  • Changez le contexte de docker cli pour pointer vers minikube avec eval et la commande précédente.
réponse:
  • Allez dans le dossier goprom_app et “construisez” l’image docker de l’application avec le tag uptimeformation/goprom.
réponse:
  • Allez dans le dossier de la première stratégie recreate et ouvrez le fichier app-v1.yml. Notez que image: est à uptimeformation/goprom et qu’un paramètre imagePullPolicy est défini à Never. Ainsi l’image sera récupéré dans le registry local du docker de minikube ou sont stockées les images buildées localement plutôt que récupéré depuis un registry distant.

  • Appliquez ce déploiement kubernetes:

réponse:

Observons notre application et son déploiement kubernetes

  • Explorez le fichier de code go de l’application main.go ainsi que le fichier de déploiement app-v1.yml. Quelles sont les routes http exposées par l’application ?
réponse:
  • Faites un forwarding de port Minikube pour accéder au service goprom dans votre navigateur.
réponse:
  • Faites un forwarding de port pour accéder au service goprom-metrics dans votre navigateur (c’est sur la route /metrics). Quelles informations récupère-t-on sur cette route ?
réponse:
  • Pour tester le service prometheus-server nous avons besoin de le mettre en mode NodePort (et non ClusterIP par défaut). Modifiez le service dans Lens pour changer son type.

  • Exposez le service avec Minikube (n’oubliez pas de préciser le namespace monitoring).

  • Vérifiez que prometheus récupère bien les métriques de l’application avec la requête PromQL : sum(rate(http_requests_total{app="goprom"}[5m])) by (version).

  • Quelle est la section des fichiers de déploiement qui indique à prometheus ou récupérer les métriques ?

réponse:

Installer et configurer Grafana pour visualiser les requêtes

Grafana est une interface de dashboard de monitoring facilement intégrable avec Prometheus. Elle va nous permettre d’afficher un histogramme en temps réel du nombre de requêtes vers l’application.

Créez un secret Kubernetes pour stocker le loging admin de grafana.

cat <<EOF | kubectl apply -n monitoring -f -
apiVersion: v1
kind: Secret
metadata:
  namespace: monitoring
  name: grafana-auth
type: Opaque
data:
  admin-user: $(echo -n "admin" | base64 -w0)
  admin-password: $(echo -n "admin" | base64 -w0)
EOF

Ensuite, installez le chart Grafana en précisant quelques paramètres:

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update
helm install \
  --namespace=monitoring \
  --version=6.1.17 \
  --set=admin.existingSecret=grafana-auth \
  --set=service.type=NodePort \
  --set=service.nodePort=32001 \
  grafana \
  grafana/grafana

Maintenant Grafana est installé vous pouvez y acccéder en forwardant le port du service grace à Minikube:

$ minikube service grafana

Pour vous connectez utilisez, username: admin, password: admin.

Il faut ensuite connecter Grafana à Prometheus, pour ce faire ajoutez une DataSource:

Name: prometheus
Type: Prometheus
Url: http://prometheus-server
Access: Server

Créer une dashboard avec un Graphe. Utilisez la requête prometheus (champ query suivante):

sum(rate(http_requests_total{app="goprom"}[5m])) by (version)

Pour avoir un meilleur aperçu de la version de l’application accédée au fur et à mesure du déploiement, ajoutez {{version}} dans le champ legend.

Observer un basculement de version

Ce TP est basé sur l’article suivant: https://blog.container-solutions.com/kubernetes-deployment-strategies

Maintenant que l’environnement a été configuré :

  • Lisez l’article.
  • Vous pouvez testez les différentes stratégies de déploiement en lisant leur README.md.
  • En résumé, pour les plus simple, on peut:
    • appliquer le fichier app-v1.yml pour une stratégie.
    • lançer la commande suivante pour effectuer des requêtes régulières sur l’application: service=$(minikube service goprom --url) ; while sleep 0.1; do curl "$service"; done
    • Dans un second terminal (pendant que les requêtes tournent) appliquer le fichier app-v2.yml correspondant.
    • Observez la réponse aux requêtes dans le terminal ou avec un graphique adapté dans graphana (Il faut configurer correctement le graphique pour observer de façon lisible la transition entre v1 et v2). Un aperçu en image des histogrammes du nombre de requêtes en fonction des versions 1 et 2 est disponible dans chaque dossier de stratégie.
    • supprimez le déploiement+service avec delete -f ou dans Lens.

Par exemple pour la stratégie recreate le graphique donne:

Facultatif : Installer Istio pour des scénarios plus avancés

Pour des scénarios plus avancés de déploiement, on a besoin d’utiliser un service mesh. Un des plus connus est Istio.

  1. Sur k3s, supprimer la release Helm de Traefik pour remplacer le Ingress Controller Traefik par Istio.
  2. Installer Istio, créer du trafic vers l’ingress de l’exemple et afficher le graphe de résultat dans le dashboard Istio : https://istio.io/latest/docs/setup/getting-started/
  3. Utiliser ces deux ressources pour appliquer une stratégie de déploiement de type A/B testing poussée :

Ansible

Module 1

Ansible

Découvrir le couteau suisse de l’automatisation et de l’infrastructure as code.

Cours 1 - Présentation

Présentation d’Ansible

Ansible

Ansible est un gestionnaire de configuration et un outil de déploiement et d’orchestration très populaire et central dans le monde de l'infrastructure as code (IaC).

Il fait donc également partie de façon centrale du mouvement DevOps car il s’apparente à un véritable couteau suisse de l’automatisation des infrastructures.

Histoire

Ansible a été créé en 2012 (plus récent que ses concurrents Puppet et Chef) autour d’une recherche de simplicité et du principe de configuration agentless.

Très orienté linux/opensource et versatile il obtient rapidement un franc succès et s’avère être un couteau suisse très adapté à l’automatisation DevOps et Cloud dans des environnements hétérogènes.

Red Hat rachète Ansible en 2015 et développe un certain nombre de produits autour (Ansible Tower, Ansible container avec Openshift).

Architecture : simplicité et portabilité avec ssh et python

Ansible est agentless c’est à dire qu’il ne nécessite aucun service/daemon spécifique sur les machines à configurer.

La simplicité d’Ansible provient également du fait qu’il s’appuie sur des technologies linux omniprésentes et devenues universelles.

  • ssh : connexion et authentification classique avec les comptes présents sur les machines.
  • python : multiplateforme, un classique sous linux, adapté à l’admin sys et à tous les usages.

De fait Ansible fonctionne efficacement sur toutes les distributions linux, debian, centos, ubuntu en particulier (et maintenant également sur Windows).

Ansible pour la configuration

Ansible est semi-déclaratif c’est à dire qu’il s’exécute séquentiellement mais idéalement de façon idempotente.

Il permet d’avoir un état descriptif de la configuration:

  • qui soit auditable
  • qui peut évoluer progressivement
  • qui permet d'éviter que celle-ci ne dérive vers un état inconnu

Ansible pour le déploiement et l’orchestration

Peut être utilisé pour des opérations ponctuelles comme le déploiement:

  • vérifier les dépendances et l’état requis d’un système
  • récupérer la nouvelle version d’un code source
  • effectuer une migration de base de données (si outil de migration)
  • tests opérationnels (vérifier qu’un service répond)

Ansible à différentes échelles

Les cas d’usages d’Ansible vont de …:

  • petit:

    • … un petit playbook (~script) fourni avec le code d’un logiciel pour déployer en mode test.
    • … la configuration d’une machine de travail personnelle.
    • etc.
  • moyen:

    • … faire un lab avec quelques machines.
    • … déployer une application avec du code, une runtime (php/java, etc.) et une base de données à migrer.
    • etc.
  • grand:

    • … gestion de plusieurs DC avec des produits multiples.
    • … gestion multi-équipes et logging de toutes les opérations grâce à Ansible Tower.
    • etc.

Ansible et Docker

Ansible est très complémentaire à docker:

  • Il permet de provisionner des machines avec docker ou kubernetes installé pour ensuite déployer des conteneurs.
  • Il permet une orchestration simple des conteneurs avec le module docker_container.

Maintenant un peu abandonné, Ansible Container rend possible de construire et déployer des conteneurs docker avec du code ansible. Concrètement le langage Ansible remplace le langage Dockerfile pour la construction des images Docker.

Partie 1, Installation, configuration

Pour l’installation plusieurs options sont possibles:

  • Avec pip le gestionnaire de paquet du langage python: pip3 install ansible

    • installe la dernière version stable (2.8 actuellement)
    • commande d’upgrade spécifique pip3 install ansible --upgrade
    • possibilité d’installer facilement une version de développement pour tester de nouvelles fonctionnalité ou anticiper les migrations.
  • Avec le gestionnaire de paquet de la distribution ou homebrew sur OSX:

    • version généralement plus ancienne (2.4 ou 2.6)
    • facile à mettre à jour avec le reste du système
    • Pour installer une version récente on il existe des dépots spécifique à ajouter: exemple sur ubuntu: sudo apt-add-repository --yes --update ppa:ansible/ansible

Pour voir l’ensemble des fichiers installés par un paquet pip3 :

pip3 show -f ansible | less

Pour tester la connexion aux serveurs on utilise la commande ad hoc suivante. ansible all -m ping

Les inventaires statiques

Il s’agit d’une liste de machines sur lesquelles vont s’exécuter les modules Ansible. Les machines de cette liste sont:

  • la syntaxe par défaut est celle des fichiers de configuration INI
  • Classées par groupe et sous groupes pour être désignables collectivement (ex: exécuter telle opération sur les machines de tel groupe)
  • La méthode de connexion est précisée soit globalement soit pour chaque machine.
  • Des variables peuvent être définies pour chaque machine ou groupe pour contrôler dynamiquement par la suite la configuration ansible.

exemple:

[all:vars]
ansible_ssh_user=elie
ansible_python_interpreter=/usr/bin/python3

[worker_nodes]
workernode1 ansible_host=10.164.210.101 pays=France

[dbservers]
pgnode1 ansible_host=10.164.210.111 pays=France
pgnode2 ansible_host=10.164.210.112 pays=Allemagne

[appservers]
appnode1 ansible_host=10.164.210.121
appnode2 ansible_host=10.164.210.122 pays=Allemagne

Les inventaires peuvent également être au format YAML (plus lisible mais pas toujours intuitif) ou JSON (pour les machines).

Options de connexion

On a souvent besoin dans l’inventaire de précisier plusieurs options pour se connecter. Voici les principales :

  • ansible_host : essentiel, pour dire à Ansible comment accéder à l’host
  • ansible_user : quel est l’user à utiliser par Ansible pour la connexion SSH
  • ansible_ssh_private_key_file : où se trouve la clé privée pour la connexion SSH
  • ansible_connection : demander à Ansible d’utiliser autre chose que du SSH pour la connexion
  • ansible_python_interpreter=/usr/bin/python3 : option parfois nécessaire pour spécifier à Ansible où trouver Python sur la machine installée

Configuration

Ansible se configure classiquement au niveau global dans le dossier /etc/ansible/ dans lequel on retrouve en autre l’inventaire par défaut et des paramètre de configuration.

Ansible est très fortement configurable pour s’adapter à des environnement contraints. Liste des paramètre de configuration:

Alternativement on peut configurer ansible par projet avec un fichier ansible.cfg présent à la racine. Toute commande ansible lancée à la racine du projet récupère automatiquement cette configuration.

Commençons le TP1

TP1 - Mise en place d'Ansible, commandes Ad Hoc et premier playbook

Installation de Ansible

  • Installez Ansible au niveau du système avec pip en lançant:

pip install ansible

  • Affichez la version pour vérifier que c’est bien la dernière stable.
ansible --version
=> 2.9.x
  • Traditionnellement lorsqu’on veut vérifier le bon fonctionnement d’une configuration on utilise ansible all -m ping. Que signifie-t-elle ?
Réponse :
  • Lancez la commande précédente. Que ce passe-t-il ?
Réponse :
  • Utilisez en plus l’option -vvv pour mettre en mode très verbeux. Ce mode est très efficace pour débugger lorsqu’une erreur inconnue se présente. Que se passe-t-il avec l’inventaire ?
Réponse :
  • Testez l’installation avec la commande ansible en vous connectant à votre machine localhost et en utilisant le module ping.
Réponse :
  • Ajoutez la ligne hotelocal ansible_host=127.0.0.1 ansible_connection=local dans l’inventaire par défaut (le chemin est indiqué dans). Et pinguer hotelocal.

Autocomplete

python3 -m pip install --user argcomplete
activate-global-python-argcomplete --user

Explorer LXD / Incus

LXD est une technologie de conteneurs actuellement promue par Canonical (ubuntu) qui permet de faire des conteneur linux orientés systèmes plutôt qu’application. Par exemple systemd est disponible à l’intérieur des conteneurs contrairement aux conteneurs Docker. Incus est le successeur de LXD, abandonné par ses devs à cause des choix de Canonical.

  • Affichez la liste des conteneurs avec incus list. Aucun conteneur ne tourne.

  • Maintenant lançons notre premier conteneur centos avec incus launch images:centos/7/amd64 centos1.

  • Listez à nouveau les conteneurs lxc.

  • Ce conteneur est un centos minimal et n’a donc pas de serveur SSH pour se connecter. Pour lancez des commandes dans le conteneur on utilise une commande LXC pour s’y connecter incus exec <non_conteneur> -- <commande>. Dans notre cas nous voulons lancer bash pour ouvrir un shell dans le conteneur : incus exec centos1 -- bash.

  • Nous pouvons installer des logiciels dans le conteneur comme dans une VM. Pour sortir du conteneur on peut simplement utiliser exit.

  • Un peu comme avec Docker, LXC utilise des images modèles pour créer des conteneurs. Affichez la liste des images avec incus image list. Trois images sont disponibles l’image centos vide téléchargée et utilisée pour créer centos1 et deux autres images préconfigurée ubuntu_ansible et centos_ansible. Ces images contiennent déjà la configuration nécessaire pour être utilisée avec ansible (SSH + Python + Un utilisateur + une clé SSH).

  • Supprimez la machine centos1 avec incus stop centos1 && incus delete centos1 –>

Configurer des images prêtes pour Ansible

Nous avons besoin d’images Linux configurées avec SSH, Python et un utilisateur de connexion (disposant idéalement d’une clé ssh configurée pour éviter d’avoir à utiliser un mot de passe de connection)

Facultatif :

Lancer et tester les conteneurs

Créons à partir des images du remotes un conteneur ubuntu et un autre centos:

incus launch ubuntu_ansible ubu1
incus launch centos_ansible centos1
  • Pour se connecter en SSH nous allons donc utiliser une clé SSH appelée id_ed25519 qui devrait être présente dans votre dossier ~/.ssh/. Vérifiez cela en lançant ls -l /home/stagiaire/.ssh.
  • Essayez de vous connecter à ubu1 et centos1 en ssh pour vérifier que la clé ssh est bien configurée et vérifiez dans chaque machine que le sudo est configuré sans mot de passe avec sudo -i.

Créer un projet de code Ansible

Lorsqu’on développe avec Ansible il est conseillé de le gérer comme un véritable projet de code :

  • versionner le projet avec Git
  • Ajouter tous les paramètres nécessaires dans un dossier pour être au plus proche du code. Par exemple utiliser un inventaire inventory.cfg ou hosts et une configuration locale au projet ansible.cfg

Nous allons créer un tel projet de code pour la suite du tp1

  • Créez un dossier projet tp1 sur le Bureau.
Facultatif :
  • Ouvrez Visual Studio Code.
  • Installez l’extension Ansible dans VSCode.
  • Ouvrez le dossier du projet avec Open Folder...

Un projet Ansible implique généralement une configuration Ansible spécifique décrite dans un fichier ansible.cfg

  • Ajoutez à la racine du projet un tel fichier ansible.cfg avec à l’intérieur:
[defaults]
inventory = ./inventory.cfg
roles_path = ./roles
host_key_checking = false # nécessaire pour les labs ou on créé et supprime des machines constamment avec des signatures SSH changées.
stdout_callback = yaml
bin_ansible_callbacks = True
  • Créez le fichier d’inventaire spécifié dans ansible.cfg et ajoutez à l’intérieur notre nouvelle machine hote1. Il faut pour cela lister les conteneurs lxc lancés.
incus list # récupérer l'ip de la machine

Générez une clé si elle n’existe pas avec ssh-keygen.

On va copier cette clé à distance avec ssh-copy-id.

Créez et complétez le fichier inventory.cfg d’après ce modèle:

ubu1 ansible_host=<ip>

[all:vars]
ansible_user=stagiaire

Contacter nos nouvelles machines

Ansible cherche la configuration locale dans le dossier courant. Conséquence: on lance généralement toutes les commandes ansible depuis la racine de notre projet.

  • Dans le dossier du projet, essayez de relancer la commande ad-hoc ping sur cette machine.

  • Ansible implique le cas échéant (login avec clé ssh) de déverrouiller la clé ssh pour se connecter à chaque hôte. Lorsqu’on en a plusieurs il est donc nécessaire de la déverrouiller en amont avec l’agent ssh pour ne pas perturber l’exécution des commandes ansible. Pour cela : ssh-add.

  • Créez un groupe adhoc_lab et ajoutez les deux machines ubu1 et centos1.

Réponse :
  • Lancez ping sur les deux machines.
Réponse :
  • Nous avons jusqu’à présent utilisé une connexion ssh par clé et précisé l’utilisateur de connexion dans le fichier ansible.cfg. Cependant on peut aussi utiliser une connexion par mot de passe et préciser l’utilisateur et le mot de passe dans l’inventaire ou en lançant la commande.

En précisant les paramètres de connexion dans le playbook il et aussi possible d’avoir des modes de connexion différents pour chaque machine.

Installons nginx avec quelques modules

  • Modifiez l’inventaire pour créer deux sous-groupes de adhoc_lab, centos_hosts et ubuntu_hosts avec deux machines dans chacun. (utilisez pour cela [adhoc_lab:children])
[all:vars]
ansible_user=stagiaire

[ubuntu_hosts]
ubu1 ansible_host=<ip>

[centos_hosts]
centos1 ansible_host=<ip>

[adhoc_lab:children]
ubuntu_hosts
centos_hosts

Dans un inventaire ansible on commence toujours par créer les plus petits sous groupes puis on les rassemble en plus grands groupes.

  • Pinguer chacun des 3 groupes avec une commande ad hoc.

Nous allons maintenant installer nginx sur nos machines. Il y a plusieurs façons d’installer des logiciels grâce à Ansible: en utilisant le gestionnaire de paquets de la distribution ou un gestionnaire spécifique comme pip ou npm. Chaque méthode dispose d’un module ansible spécifique.

  • Si nous voulions installer nginx avec la même commande sur des machines centos et ubuntu à la fois, impossible d’utiliser apt car centos utilise dnf. Pour éviter ce problème on peut utiliser le module package qui permet d’uniformiser l’installation (pour les cas simples).

  • N’hésitez pas consulter extensivement la documentation des modules avec leur exemple ou d’utiliser la commande de documentation ansible-doc <module>

    • utilisez become pour devenir root avant d’exécuter la commande (cf élévation de privilège dans le cours2)

Commandes ad-hoc et premier playbook

Installation de Nginx

Créer un playbook

  • Créons un playbook : ajoutez un fichier tp1.yml avec à l’intérieur:
- hosts: ubu1
  
  tasks:
    - name: ping
      ping:
  • Lancez ce playbook avec la commande ansible-playbook <nom_playbook>.

  • Commençons par installer les dépendances de cette application. Tous nos serveurs d’application sont sur ubuntu. Nous pouvons donc utiliser le module apt pour installer les dépendances. Il fournit plus d’option que le module package.

  • Adaptons ce playbook rudimentaire pour installer nginx.

  • Lançons la commande en “ad-hoc” :
ansible adhoc_lab -m package -a "name=nginx state=present"
  • Lancez le playbook après avoir sauvegardé les modifications avec ansible-playbook monplaybook.yml. Si cela ne marche pas, pourquoi ?
Réponse :
  • Re-relancez la commande après avoir sauvegardé les modifications. Si cela ne marche pas, pourquoi ?

  • Re-relancez la même commande une seconde fois. Que se passe-t-il ?

Réponse :
Réponse :
  • Pour résoudre le problème sur les hôtes CentOS, installez epel-release sur la machine CentOS.
Réponse :
  • Relancez la commande d’installation de nginx. Que remarque-t-on ?
Réponse :

Vérifier l’état du service Nginx

  • Utiliser le module systemd et l’option --check pour vérifier si le service nginx est démarré sur chacune des 2 machines. Normalement vous constatez que le service est déjà démarré (par défaut) sur la machine ubuntu et non démarré sur la machine centos.
Réponse :
  • L’option --check sert à vérifier l’état des ressources sur les machines mais sans modifier la configuration`. Relancez la commande précédente pour le vérifier. Normalement le retour de la commande est le même (l’ordre peut varier).

  • Lancez la commande ou le playbook avec state à stopped : le retour est inversé.

  • Enlevez le --check pour vous assurer que le service est démarré sur chacune des machines.

  • Visitez dans un navigateur l’ip d’un des hôtes pour voir la page d’accueil nginx.

Les variables en Ansible, les Ansible Facts et les templates Jinja2

Nous allons faire que la page d’accueil Nginx affiche des données extraites d’Ansible.

  • créons un fichier nommé nginx_index.j2 avec le contenu suivant :
Nom de l'hôte Ansible : {{ ansible_hostname }}
Système d'exploitation : {{ ansible_distribution }} {{ ansible_distribution_version }}
Architecture CPU : {{ ansible_facts['architecture'] }}

Ces variables sont des variables issues de l’étape de collecte de facts Ansible (si on ne les collecte pas, la task échouera).

Afficher le template comme page d’accueil Nginx

  • Avec la documentation du module copy:, copiez le fichier nginx_index.j2 à l’emplacement de la configuration Nginx par défaut (c’est /var/www/html/index.html pour Ubuntu).
  • En modifiant le module utilisé de copy: à template: et en réexécutant le playbook avec l’option --diff, observez les changements qu’Ansible fait au fichier.

Pour cela nous allons partir à la découverte des variables fournies par Ansible.

Les Ansible Facts

Dans Ansible, on peut accéder à la variable ansible_facts : ce sont les faits récoltés par Ansible sur l’hôte en cours.

Pour explorer chacune de ces variables vous pouvez utiliser le module debug dans un playbook:

- name: show vars
  debug:
    msg: "{{ ansible_facts }}"

Vous pouvez aussi exporter les “facts” d’un hôte en JSON pour plus de lisibilité : ansible all -m setup --tree ./ansible_facts_export

Puis les lire avec cat ./ansible_facts_export/votremachine.json | jq (il faut que jq soit installé, sinon tout ouvrir dans VSCode avec code ./ansible_facts_export).

  • utilisez jq pour extraire et visualiser des informations spécifiques à partir du fichier JSON. Par exemple, pour voir le type de virtualisation détecté :
cat /tmp/ansible_facts/<nom_hôte_ou_IP>.json | jq '.ansible_facts.ansible_virtualization_type'

Ansible et les commandes unix

Il existe trois façon de lancer des commandes unix avec ansible:

  • le module command utilise python pour lancez la commande.

    • les pipes et syntaxes bash ne fonctionnent pas.
    • il peut executer seulement les binaires.
    • il est cependant recommandé quand c’est possible car il n’est pas perturbé par l’environnement du shell sur les machine et donc plus prévisible.
  • le module shell utilise un module python qui appelle un shell pour lancer une commande.

    • fonctionne comme le lancement d’une commande shell mais utilise un module python.
  • le module raw.

    • exécute une commande ssh brute.
    • ne nécessite pas python sur l’hote : on peut l’utiliser pour installer python justement.
    • ne dispose pas de l’option creates pour simuler de l’idempotence.
  • Créez un fichier dans /tmp avec touch et l’un des modules précédents.

  • Relancez la commande. Le retour est toujours changed car ces modules ne sont pas idempotents.

  • Relancer l’un des modules shell ou command avec touch et l’option creates pour rendre l’opération idempotente. Ansible détecte alors que le fichier témoin existe et n’exécute pas la commande.

Réponse :

Cours 2 - Les playbooks Ansible

Les commandes ad-hoc sont des appels directs de modules Ansible qui fonctionnent de façon idempotente mais ne présente pas les avantages du code qui donne tout son intérêt à l’IaC:

  • texte descriptif écrit une fois pour toute
  • logique lisible et auditable
  • versionnable avec git
  • reproductible et incrémental

La dimension incrémentale du code rend en particulier plus aisé de construire une infrastructure progressivement en la complexifiant au fur et à mesure plutôt que de devoir tout plannifier à l’avance.

Le playbook est une sorte de script ansible, c’est à dire du code. Le nom provient du football américain : il s’agit d’un ensemble de stratégies qu’une équipe a travaillé pour répondre aux situations du match. Elle insiste sur la versatilité de l’outil.

La commande ansible-playbook

  • version minimale : ansible-playbook mon-playbook.yml
  • version plus complète : ansible-playbook <fichier_playbook> --limit <groupe_machine> --inventory <fichier_inventaire> --become -vv --diff

Le mode --check et l’option --diff

  • Très utile, le mode --check sert à vérifier l’état des ressources sur les machines (dry-run) mais sans modifier la configuration.

  • L’option --diff permet d’afficher les différences entre la configuration actuelle et la configuration après les changements effectués par les différentes tasks.

Une bonne commande est par exemple : ansible-playbook --check -vv --diff

Cette commande permet de lancer une simulation d’exécution de playbook, et d’afficher les différences entre la configuration actuelle et la configuration désirée (qui aurait été atteinte sans le --check).

Les modules Ansible

Ansible fonctionne grâce à des modules python téléversés sur sur l’hôte à configurer puis exécutés. Ces modules sont conçus pour être cohérents et versatiles et rendre les tâches courantes d’administration plus simples.

Il en existe pour un peu toute les tâches raisonnablement courantes : un slogan Ansible “Batteries included” ! Plus de 1300 modules sont intégrés par défaut.

  • ping: un module de test Ansible (pas seulement réseau comme la commande ping)

  • dnf/apt: pour gérer les paquets sur les distributions basées respectivement sur Red Hat ou Debian.

  • systemd (ou plus générique service): gérer les services/daemons d’un système.
  • user: créer des utilisateurs et gérer leurs options/permission/groupes

  • file: pour créer, supprimer, modifier, changer les permission de fichiers, dossier et liens.

Option et documentation des modules

La documentation des modules Ansible se trouve à l’adresse https://docs.ansible.com/ansible/latest/modules/file_module.html

Chaque module propose de nombreux arguments pour personnaliser son comportement:

exemple: le module file permet de gérer de nombreuses opérations avec un seul module en variant les arguments.

Il est également à noter que la plupart des arguments sont facultatifs.

  • cela permet de garder les appel de modules très succints pour les taches par défaut
  • il est également possible de rendre des paramètres par défaut explicites pour augmenter la clarté du code.

Exemple et bonne pratique: toujours préciser state: present même si cette valeur est presque toujours le défaut implicite.

Syntaxe yaml

Les playbooks ansible sont écrits au format YAML.

  • YAML est basé sur les identations à base d’espaces (2 espaces par indentation en général). Comme le langage python.
  • C’est un format assez lisible et simple à écrire bien que les indentations soient parfois difficiles à lire.
  • C’est un format assez flexible avec des types liste et dictionnaires qui peuvent s’imbriquer.
  • Le YAML est assez proche du JSON (leur structures arborescentes typées sont isomorphes) mais plus facile à écrire.

A quoi ça ressemble ?

Une liste

- 1
- Poire
- "Message à caractère informatif"

Un dictionnaire

clé1: valeur1
clé2: valeur2
clé3: 3

Un exemple imbriqué plus complexe

marché: # debut du dictionnaire global "marché"
  lieu: Crimée Curial
  jour: dimanche
  horaire:
    unité: "heure"
    min: 9


    max: 14 # entier
  fruits: #liste de dictionnaires décrivant chaque fruit
    - nom: pomme
      couleur: "verte"
      pesticide: avec #les chaines sont avec ou sans " ou '
            # on peut sauter des lignes dans interrompre la liste ou le dictionnaire en court
    - nom: poires
      couleur: jaune
      pesticide: sans
  légumes: #Liste de 3 éléments
    - courgettes
    - salade

    - potiron
#fin du dictionnaire global

Pour mieux visualiser l’imbrication des dictionnaires et des listes en YAML on peut utiliser un convertisseur YAML -> JSON : https://www.json2yaml.com/.

Notre marché devient:

{
  "marché": {
    "lieu": "Crimée Curial",
    "jour": "dimanche",
    "horaire": {
      "unité": "heure",
      "min": 9,
      "max": 14
    },
    "fruits": [
      {
        "nom": "pomme",
        "couleur": "verte",
        "pesticide": "avec"
      },
      {
        "nom": "poires",
        "couleur": "jaune",
        "pesticide": "sans"
      }
    ],
    "légumes": [
      "courgettes",
      "salade",
      "potiron"
    ]
  }
}

Observez en particulier la syntaxe assez condensée de la liste “fruits” en YAML qui est une liste de dictionnaires.

Structure d’un playbook

Version simplifiée

--- 
  # (chaque play commence par un tiret)
- hosts: web # une machine ou groupe de machines
  become: yes # lancer le playbook avec "sudo"

  vars:
    logfile_name: "auth.log"

  vars_files:
    - mesvariables.yml

  roles:
    - flaskapp
    
  tasks:

    - name: créer un fichier de log
      file: # syntaxe yaml extensive : conseillée
        path: /var/log/{{ logfile_name }} #guillemets facultatifs
        mode: 755

    - import_tasks: mestaches.yml

  handlers:
    - systemd:
        name: nginx
        state: "reloaded"

Version plus exhaustive

--- 
- name: premier play # une liste de play (chaque play commence par un tiret)
  hosts: serveur_web # un premier play
  become: yes
  gather_facts: false # récupérer le dictionnaires d'informations (facts) relatives aux machines

  vars:
    logfile_name: "auth.log"

  vars_files:
    - mesvariables.yml

  pre_tasks:
    - name: dynamic variable
      set_fact:
        mavariable: "{{ inventory_hostname + '_prod' }}" #guillemets obligatoires

  roles:
    - flaskapp
    
  tasks:
    - name: installer le serveur nginx
      apt: name=nginx state=present # syntaxe concise proche des commandes ad hoc mais moins lisible

    - name: créer un fichier de log
      file: # syntaxe yaml extensive : conseillée
        path: /var/log/{{ logfile_name }} #guillemets facultatifs
        mode: 755

    - import_tasks: mestaches.yml

  handlers:
    - systemd:
        name: nginx
        state: "reloaded"

- name: un autre play
  hosts: dbservers
  tasks:
    ... 
  • Un playbook commence par un tiret car il s’agit d’une liste de plays.

  • Un play est un dictionnaire yaml qui décrit un ensemble de tâches ordonnées en plusieurs sections. Un play commence par préciser sur quelles machines il s’applique puis précise quelques paramètres faculatifs d’exécution comme become: yes pour l’élévation de privilège (section hosts).

  • La section hosts est obligatoire. Toutes les autres sections sont facultatives !

  • La section tasks est généralement la section principale car elle décrit les tâches de configuration à appliquer.

  • La section tasks peut être remplacée ou complétée par une section roles et des sections pre_tasks post_tasks

  • Les handlers sont des tâches conditionnelles qui s’exécutent à la fin (post traitements conditionnels comme le redémarrage d’un service)

Élévation de privilège

L’élévation de privilège est nécessaire lorsqu’on a besoin d’être root pour exécuter une commande ou plus généralement qu’on a besoin d’exécuter une commande avec un utilisateur différent de celui utilisé pour la connexion on peut utiliser:

  • Au moment de l’exécution l’argument --become en ligne de commande avec ansible, ansible-console ou ansible-playbook.

  • La section become: yes

    • au début du play (après hosts) : toutes les tâches seront executée avec cette élévation par défaut.
    • après n’importe quelle tâche : l’élévation concerne uniquement la tâche cible.
  • Pour executer une tâche avec un autre utilisateur que root (become simple) ou celui de connexion (sans become) on le précise en ajoutant à become: yes, become_user: username

Ordre d’exécution

  1. pre_tasks
  2. roles
  3. tasks
  4. post_tasks
  5. handlers

Les roles ne sont pas des tâches à proprement parler mais un ensemble de tâches et ressources regroupées dans un module un peu comme une librairie developpement. Cf. cours 3.

Bonnes pratiques de syntaxe

  • Indentation de deux espaces.
  • Toujours mettre un name: qui décrit lors de l’exécution de la tâche en cours : un des principes de l’IaC est l’intelligibilité des opérations.
  • Utiliser les arguments au format yaml (sur plusieurs lignes) pour la lisibilité, sauf s’il y a peu d’arguments

Pour valider la syntaxe il est possible d’installer et utiliser ansible-lint sur les fichiers YAML.

TP2 - Créer un playbook de déploiement d'application flask

Création du projet

  • Créez un nouveau dossier tp2_flask_deployment.
  • Créez le fichier ansible.cfg comme précédemment.
[defaults]
inventory = ./inventory.cfg
roles_path = ./roles
host_key_checking = false
  • Créez deux machines ubuntu ubu1 et ubu2.
incus launch ubuntu_ansible ubu1
incus launch ubuntu_ansible ubu2
  • Créez l’inventaire statique inventory.cfg.
$ incus list # pour récupérer l'adresse ip puis

[all:vars]
ansible_user=stagiaire

[appservers]
ubu1 ansible_host=10.x.y.z
ubu2 ansible_host=10.x.y.z
  • Ajoutez à l’intérieur les deux machines dans un groupe appservers.
  • Pinguez les machines.
ansible all -m ping
Facultatif :

Créer le playbook : installer les dépendances

Le but de ce projet est de déployer une application flask, c’est a dire une application web python. Le code (très minimal) de cette application se trouve sur github à l’adresse: https://github.com/e-lie/flask_hello_ansible.git.

  • N’hésitez pas consulter extensivement la documentation des modules avec leur exemple ou d’utiliser la commande de doc ansible-doc <module>

  • Créons un playbook : ajoutez un fichier flask_deploy.yml avec à l’intérieur:

- hosts: hotes_cible
  
  tasks:
    - name: ping
      ping:
  • Lancez ce playbook avec la commande ansible-playbook <nom_playbook>.

  • Commençons par installer les dépendances de cette application. Tous nos serveurs d’application sont sur ubuntu. Nous pouvons donc utiliser le module apt pour installer les dépendances. Il fournit plus d’options que le module package.

Si vous avez créé une app3 sur CentOS :
  • Avec le module apt installez les applications: python3-dev, python3-pip, python3-virtualenv, virtualenv, nginx, git. Donnez à cette tache le nom: ensure basic dependencies are present. ajoutez pour cela la directive become: yes au début du playbook.

En utilisant une loop (et en accédant aux différentes valeurs qu’elle prend avec {{ item }}), on va pouvoir exécuter plusieurs fois cette tâche :

    - name: Ensure basic dependencies are present
      apt:
        name: "{{ item }}"
        state: present
      loop:
        - python3-dev
        - python3-pip
        - python3-virtualenv
        - virtualenv
        - nginx
        - git
  • Relancez bien votre playbook à chaque tâche : comme Ansible est idempotent il n’est pas grave en situation de développement d’interrompre l’exécution du playbook et de reprendre l’exécution après un échec.

  • Ajoutez une tâche systemd pour s’assurer que le service nginx est démarré.

    - name: Ensure nginx service started
      systemd:
        name: nginx
        state: started
  • Ajoutez une tâche pour créer un utilisateur flask et l’ajouter au groupe www-data. Utilisez bien le paramètre append: yes pour éviter de supprimer des groupes à l’utilisateur.
    - name: Add the user running webapp
      user:
        name: "flask"
        state: present
        append: yes # important pour ne pas supprimer les groupes d'un utilisateur existant
        groups:
          - "www-data"
Si vous avez créé une app3 sur CentOS (facultatif), cliquez ici

N’hésitez pas à tester l’option --diff -v avec vos commandes pour voir l’avant-après.

Récupérer le code de l’application

  • Pour déployer le code de l’application deux options sont possibles.

    • Télécharger le code dans notre projet et le copier sur chaque serveur avec le module sync qui fait une copie rsync.
    • Utiliser le module git.
  • Nous allons utiliser la deuxième option (git) qui est plus cohérente pour le déploiement et la gestion des versions logicielles. Allez voir la documentation pour voir comment utiliser ce module.

  • Utilisez-le pour télécharger le code source de l’application (branche master) dans le dossier /home/flask/hello mais en désactivant la mise à jour (au cas où le code change).

    - name: Git clone/update python hello webapp in user home
      git:
        repo: "https://github.com/e-lie/flask_hello_ansible.git"
        dest: /home/flask/hello
        clone: yes
        update: no
  • Lancez votre playbook et allez vérifier sur une machine en ssh que le code est bien téléchargé.

Installez les dépendances python de l’application

Le langage python a son propre gestionnaire de dépendances pip qui permet d’installer facilement les librairies d’un projet. Il propose également un méchanisme d’isolation des paquets installés appelé virtualenv. Normalement installer les dépendances python nécessite 4 ou 5 commandes shell.

  • nos dépendances sont indiquées dans le fichier requirements.txt à la racine du dossier d’application. pip a une option spéciale pour gérer ces fichiers.

  • Nous voulons installer ces dépendances dans un dossier venv également à la racine de l’application.

  • Nous voulons installer ces dépendances en version python3 avec l’argument virtualenv_python: python3.

  • même si nous pourrions demander à Ansible de lire ce fichier, créer une variable qui liste ces dépendances et les installer une par une, nous n’allons pas utiliser loop. Le but est de toujours trouver le meilleur module pour une tâche.

Avec ces informations et la documentation du module pip installez les dépendances de l’application.

Cliquez pour voir la solution :

Changer les permissions sur le dossier application

Notre application sera exécutée en tant qu’utilisateur flask pour des raisons de sécurité. Pour cela le dossier doit appartenir à cet utilisateur or il a été créé en tant que root (à cause du become: yes de notre playbook).

  • Créez une tache file qui change le propriétaire du dossier de façon récursive. N’hésitez pas à tester l’option --diff -v avec vos commandes pour voir l’avant-après.
    - name: Change permissions of app directory
      file:
        path: /home/flask/hello
        state: directory
        owner: "flask"
        group: www-data
        recurse: true

Module Template : configurer le service qui fera tourner l’application

Notre application doit tourner comme c’est souvent le cas en tant que service (systemd). Pour cela nous devons créer un fichier service adapté hello.service et le copier dans le dossier /etc/systemd/system/.

Ce fichier est un fichier de configuration qui doit contenir le texte suivant:

[Unit]
Description=Gunicorn instance to serve hello
After=network.target

[Service]
User=flask
Group=www-data
WorkingDirectory=/home/flask/hello
Environment="PATH=/home/flask/hello/venv/bin"
ExecStart=/home/flask/hello/venv/bin/gunicorn --workers 3 --bind unix:hello.sock -m 007 app:app

[Install]
WantedBy=multi-user.target

Pour gérer les fichier de configuration on utilise généralement le module template qui permet à partir d’un fichier modèle situé dans le projet ansible de créer dynamiquement un fichier de configuration adapté sur la machine distante.

  • Créez un dossier templates, avec à l’intérieur le fichier app.service.j2 contenant le texte précédent.

  • Utilisez le module template pour le copier au bon endroit avec le nom hello.service.

  • Utilisez ensuite systemd pour démarrer ce service (avec state: restarted dans le cas où le fichier a changé).

Configurer nginx

  • Comme précédemment créez un fichier de configuration hello.test.conf dans le dossier /etc/nginx/sites-available à partir du fichier modèle:

nginx.conf.j2

# {{ ansible_managed }}
# La variable du dessus indique qu'il ne faut pas modifier ce fichier directement, on peut l'écraser dans notre config Ansible pour écrire un message plus explicite à ses collègues

server {
    listen 80;

    server_name hello.test;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/flask/hello/hello.sock;
    }
}
  • Utilisez file pour créer un lien symbolique de ce fichier dans /etc/nginx/sites-enabled (avec l’option force: yes pour écraser le cas échéant). C’est une bonne pratique Nginx que nous allons respecter dans notre playbook Ansible.

  • Ajoutez une tache pour supprimer le site /etc/nginx/sites-enabled/default.

  • Ajouter une tâche de redémarrage de nginx.

  • Ajoutez l’IP de la VM puis hello.test séparé par un espace dans votre fichier /etc/hosts, pour que le domaine hello.test soit résolu par l’IP d’un des serveurs d’application.

  • Visitez l’application dans un navigateur et debugger le cas échéant.

Solution intermédiaire

flask_deploy.yml

Code de solution :
Facultatif :

Ajouter un handler pour nginx et le service

Pour le moment dans notre playbook, les deux tâches de redémarrage de service sont en mode restarted c’est à dire qu’elles redémarrent le service à chaque exécution (résultat: changed) et ne sont donc pas idempotentes. En imaginant qu’on lance ce playbook toutes les 15 minutes dans un cron pour stabiliser la configuration, on aurait un redémarrage de nginx 4 fois par heure sans raison.

On désire plutôt ne relancer/recharger le service que lorsque la configuration conrespondante a été modifiée. c’est l’objet des tâches spéciales nommées handlers.

Ajoutez une section handlers: à la suite

  • Déplacez la tâche de redémarrage/reload de nginx dans cette section et mettez comme nom reload nginx.

  • Ajoutez aux deux tâches de modification de la configuration la directive notify: <nom_du_handler>.

  • Testez votre playbook. il devrait être idempotent sauf le restart de hello.service.

  • Testez le handler en ajoutant un commentaire dans le fichier de configuration nginx.conf.j2.

    - name: template nginx site config
      template:
        src: templates/nginx.conf.j2
        dest: /etc/nginx/sites-available/{{ app.domain }}.conf
      notify: reload nginx

      ...

  handlers:
    - name: reload nginx
      systemd:
        name: "nginx"
        state: reloaded

# => penser aussi à supprimer la tâche maintenant inutile de restart de nginx précédente

Solution

  • Pour la solution complète, clonons le dépôt via cette commande :
cd # Pour revenir dans notre dossier home
git clone https://github.com/Uptime-Formation/ansible-tp-solutions -b tp2_correction tp2_before_handlers

Vous pouvez également consulter la solution directement sur le site de Github : https://github.com/Uptime-Formation/ansible-tp-solutions/tree/tp2_correction

Amélioration A : faire varier le playbook selon les OS

Nous allons tenter de créer une nouvelle version de votre playbook pour qu’il soit portable entre CentOS et Ubuntu.

  • Pour cela, utilisez la directive when: ansible_os_family == 'Debian' ou RedHat (on pourra aussi utiliser des modules génériques comme package: au lieu de apt:, ou service: au lieu de systemd:). Cette directive peut s’utiliser sur toutes les tâches.

  • N’oubliez pas d’installer epel-release qui est nécessaire à CentOS.

  • Il va falloir adapter le nom des packages à CentOS.

  • Pour le nom du user Nginx, on pourrait ajouter une section de playbook appelée vars: et définir quelque chose comme nginx_user: "{{ 'nginx' if ansible_os_family == "RedHat" else 'www-data' }}

  • De même, les fichiers Nginx ne sont pas forcément au même endroit dans CentOS : il n’y a pas de notion de sites-enabled dans Nginx, il suffit de copier un fichier de config dans /etc/nginx/conf.d à la place (pas de lien symbolique).

Amélioration B : un handler en deux parties en testant la config de Nginx avant de reload

On peut utiliser l’attribut listen dans le handler pour décomposer un handler en plusieurs étapes. Avec nginx -t, testons la config de Nginx dans le handler avant de reload. Documentation : https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_handlers.html#naming-handlers

Amélioration C : faire fonctionner le playbook en check mode

Certaines tâches ne peuvent fonctionner sur une nouvelle machine en check mode. Pour tester, créons une nouvelle machine et exécutons le playbook avec --check. Avec ignore_errors: et {{ ansible_check_mode }}, résolvons le problème.

Amélioration D : modifier le /etc/hosts via le playbook

A l’aide de la documentation de l’option delegate: et du module lineinfile, trouvez comment ajouter une tâche qui modifie automatiquement votre /etc/hosts pour ajouter une entrée liant le nom de domaine de votre app à l’IP du conteneur (il faudra utiliser la variable ansible_host et celle du nom de domaine). Idéalement, on utiliserait la regex .* {{ app.domain }} pour gérer les variations d’adresse IP

Dans le cas de plusieurs hosts hébergeant nos apps, on pourrait même ajouter une autre entrée DNS pour préciser à quelle instance de notre app nous voulons accéder. Sans cela, nous sommes en train de faire une sorte de loadbalancing via le DNS.

Pour info : la variable {{ inventory_hostname }} permet d’accéder au nom que l’on a donné à une machine dans l’inventaire.

Amélioration E : l’attribut register:

  • Avec le module command, listez les configs activées dans Nginx, utilisez la directive register: pour la mettre dans une variable.

  • Ajoutez une tâche de debug: qui affiche le contenu de cette variable (avec {{ }})

Réorganisation : rendre le playbook dynamique avec des variables, puis une boucle, pour se préparer aux rôles

Améliorer notre playbook avec des variables

Ajoutons des variables pour gérer dynamiquement les paramètres de notre déploiement:

  • Ajoutez une section vars: avant la section tasks: du playbook.

  • Mettez dans cette section la variable suivante (dictionnaire):

  app:
    name: hello
    user: flask
    domain: hello.test

(il faudra modifier votre fichier /etc/hosts pour faire pointer le domaine hello.test vers l’IP de votre conteneur)

  • ajoutons une petite task dans la section pre_tasks: pour afficher cette variable au début du playbook, c’est le module debug :
  pre_tasks:
    - debug:
        msg: "{{ app }}"
  • Remplacez dans le playbook précédent et les deux fichiers de template:

    • toutes les occurences de la chaine hello par {{ app.name }}
    • toutes les occurences de la chaine flask par {{ app.user }}
    • toutes les occurences de la chaine hello.test par {{ app.domain }}
  • Relancez le playbook : toutes les tâches devraient renvoyer ok à part les “restart” car les valeurs sont identiques.

Facultatif :
  • Pour la solution intermédiaire, clonons le dépôt via cette commande :
cd # Pour revenir dans notre dossier home
git clone https://github.com/Uptime-Formation/ansible-tp-solutions -b tp2_before_handlers_correction tp2_before_handlers

Vous pouvez également consulter la solution directement sur le site de Github : https://github.com/Uptime-Formation/ansible-tp-solutions/tree/tp2_before_handlers_correction

Rendre le playbook dynamique avec une boucle

Nous allons nous préparer à transformer ce playbook en rôle, plus général.

Plutôt qu’une variable app unique on voudrait fournir au playbook une liste d’application à installer (liste potentiellement définie durant l’exécution).

  • Identifiez dans le playbook précédent les tâches qui sont exactement communes à l’installation des deux apps.

    Réponse :

  • Créez un nouveau fichier deploy_app_tasks.yml et copier à l’intérieur la liste de toutes les autres tâches mais sans les handlers que vous laisserez à la fin du playbook.

Réponse :

Ce nouveau fichier n’est pas à proprement parler un playbook mais une liste de tâches.

  • Utilisez include_tasks: (cela se configure comme une task un peu spéciale) pour importer cette liste de tâches à l’endroit où vous les avez supprimées.

  • Vérifiez que le playbook fonctionne et est toujours idempotent. Note: si vous avez récupéré une solution, il va falloir récupérer le fichier d’inventaire d’un autre projet et adapter la section hosts: du playbook.

  • Ajoutez une tâche debug: msg={{ app }} (c’est une syntaxe abrégée appelée free-form ) au début du playbook pour visualiser le contenu de la variable. Note : La version non-free-form (version longue) de cette tâche est :

debug:
  msg: {{ app }}
  • Ensuite remplacez la variable app par une liste flask_apps de deux dictionnaires (avec name, domain, user différents les deux dictionnaires et repository et version identiques).
flask_apps:
  - name: hello
    domain: "hello.test"
    user: "flask"
    version: master
    repository: https://github.com/e-lie/flask_hello_ansible.git

  - name: hello2
    domain: "hello2.test"
    user: "flask2"
    version: version2
    repository: https://github.com/e-lie/flask_hello_ansible.git

Il faudra modifier la tâche de debug par debug: msg={{ flask_apps }}. Observons le contenu de cette variable.

  • A la task debug:, ajoutez la directive loop: "{{ flask_apps }} (elle se situe à la hauteur du nom de la task et du module) et remplacez le msg={{ flask_apps }} par msg={{ item }}. Que se passe-t-il ? note: il est normal que le playbook échoue désormais à l’étape include_tasks

La directive loop_var permet de renommer la variable sur laquelle on boucle par un nom de variable de notre choix. A quoi sert-elle ? Rappelons-nous : sans elle, on accéderait à chaque item de notre liste flask_apps avec la variable item. Cela nous permet donc de ne pas modifier toutes nos tasks utilisant la variable app et de ne pas avoir à utiliser item à la place.

  • Utilisez la directive loop et loop_control+loop_var sur la tâche include_tasks pour inclure les tâches pour chacune des deux applications, en complétant comme suit :
- include_tasks: deploy_app_tasks.yml
  loop: "{{ A_COMPLETER }}"
  loop_control:
    loop_var: A_COMPLETER
  • Créez le dossier group_vars et déplacez le dictionnaire flask_apps dans un fichier group_vars/appservers.yml. Comme son nom l’indique ce dossier permet de définir les variables pour un groupe de serveurs dans un fichier externe.

  • Testez en relançant le playbook que le déplacement des variables est pris en compte correctement.

  • Pour la solution : activez la branche tp2_correction avec git checkout tp2_correction.

Bonus : pour pratiquer

Essayez de déployer une version plus complexe d’application flask avec une base de donnée mysql : https://github.com/miguelgrinberg/microblog/tree/v0.17

Il s’agit de l’application construite au fur et à mesure dans un magnifique tutoriel python. Ce chapitre indique comment déployer l’application sur linux.

Cours 3 - Les variables, les structures de contrôle et les templates Jinja2

Variables Ansible

Ansible utilise en arrière plan un dictionnaire contenant de nombreuses variables.

Pour s’en rendre compte on peut lancer : ansible <hote_ou_groupe> -m debug -a "msg={{ hostvars }}"

Ce dictionnaire contient en particulier:

  • des variables de configuration ansible (ansible_user par exemple)
  • les ansible_facts, c’est à dire des variables dynamiques caractérisant les systèmes cible (par exemple ansible_os_family) et récupéré au lancement d’un playbook.
  • des variables personnalisées (de l’utilisateur) que vous définissez avec vos propre nom généralement en snake_case.

Définition des variables

On peut définir et modifier la valeur des variables à différents endroits du code ansible:

  • La section vars: du playbook.
  • Un fichier de variables appelé avec vars_files:
  • L’inventaire : variables pour chaque machine ou pour le groupe.
  • Dans des dossier extension de l’inventaire group_vars, host_vars
  • Dans le dossier defaults des roles (cf partie sur les roles)
  • Dans une tâche avec le module set_facts.
  • Au runtime au moment d’appeler la CLI ansible avec --extra-vars "version=1.23.45 other_variable=foo"

Lorsque définies plusieurs fois, les variables ont des priorités en fonction de l’endroit de définition. L’ordre de priorité est plutôt complexe: https://docs.ansible.com/ansible/latest/user_guide/playbooks_variables.html#variable-precedence-where-should-i-put-a-variable

En résumé la règle peut être exprimée comme suit: les variables de runtime sont prioritaires sur les variables dans un playbook qui sont prioritaires sur les variables de l’inventaire qui sont prioritaires sur les variables par défaut d’un role.

  • Bonne pratique: limiter les redéfinitions de variables en cascade (au maximum une valeur par défaut, une valeur contextuelle et une valeur runtime) pour éviter que le playbook soit trop complexe et difficilement compréhensible et donc maintenable.

Variables spéciales

https://docs.ansible.com/ansible/latest/reference_appendices/special_variables.html

Les plus utiles:

  • ansible_facts: faits récoltés par Ansible (Ansible Facts) sur l’hôte en cours
  • hostvars: dictionaire de toute les variables rangées par hôte de l’inventaire.
  • ansible_host: information utilisée pour la connexion (ip ou domaine).
  • inventory_hostname: nom de la machine dans l’inventaire.
  • groups: dictionnaire de tous les groupes avec la liste des machines appartenant à chaque groupe.

Pour explorer chacune de ces variables vous pouvez utiliser le module debug en mode adhoc ou dans un playbook :

ansible <hote_ou_groupe> -m debug -a "msg={{ ansible_host }}" -vvv

Attention, les facts ne sont pas relevés en mode ad-hoc. Il faut donc utiliser le module debug.

Vous pouvez exporter les ansible_facts en JSON pour plus de lisibilité : ansible all -m setup --tree ./ansible_facts_export

Puis les lire avec cat ./ansible_facts_export/votremachine.json | jq (il faut que jq soit installé, sinon tout ouvrir dans VSCode avec code ./ansible_facts_export).

Facts

Les facts sont des valeurs de variables récupérées au début de l’exécution durant l’étape gather_facts et qui décrivent l’état courant de chaque machine.

  • Par exemple, ansible_os_family est un fact/variable décrivant le type d’OS installé sur la machine. Elle n’existe qu’une fois les facts récupérés.

Lors d’une commande adhoc ansible les facts ne sont pas récupérés : la variable ansible_os_family ne sera pas disponible.

La liste des facts peut être trouvée dans la documentation et dépend des plugins utilisés pour les récupérés: https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_vars_facts.html

Structures de contrôle Ansible

La directive when:

Elle permet de rendre une tâche conditionnelle (une sorte de if)

- name: start nginx service
  systemd:
    name: nginx
    state: started
  when: ansible_os_family == 'RedHat'

Sinon la tâche est sautée (skipped) durant l’exécution.

La directive loop:

Cette directive permet d’exécuter une tâche plusieurs fois basée sur une liste de valeurs :

https://docs.ansible.com/ansible/latest/user_guide/playbooks_loops.html

exemple:

- hosts: localhost
  tasks:
    - name: exemple de boucle
      debug:
        msg: "{{ item }}"
      loop:
        - message1
        - message2
        - message3

On accéde aux différentes valeurs qu’elle prend avec {{ item }}.

On peut également contrôler cette boucle avec quelques paramètres:

- hosts: localhost
  vars:
    messages:
      - message1
      - message2
      - message3

  tasks:
    - name: exemple de boucle
      debug:
        msg: "message numero {{ num }} : {{ message }}"
      loop: "{{ messages }}"
      loop_control:
        loop_var: message
        index_var: num
    

Cette fonctionnalité de boucle était anciennement accessible avec le mot-clé with_items: qui est maintenant déprécié.

Jinja2 et variables dans les playbooks et rôles (fichiers de code)

La plupart des fichiers Ansible (sauf l’inventaire) sont traités avec le moteur de template python Jinja2.

Ce moteur permet de créer des valeurs dynamiques dans le code des playbooks, des roles, et des fichiers de configuration.

  • Les variables écrites au format {{ mavariable }} sont remplacées par leur valeur provenant du dictionnaire d’exécution d’Ansible.

  • Des filtres (fonctions de transformation) permettent de transformer la valeur des variables: exemple : {{ hostname | default('localhost') }} (Voir plus bas)

Filtres Jinja

Pour transformer la valeur des variables à la volée lors de leur appel on peut utiliser des filtres (jinja2) :

La liste complète des filtres ansible se trouve ici : https://docs.ansible.com/ansible/latest/user_guide/playbooks_filters.html

Jinja2 et les variables dans les fichiers de templates

Les fichiers de templates (.j2) utilisés avec le module template, généralement pour créer des fichiers de configuration peuvent contenir des variables et des filtres comme les fichier de code (voir au dessus) mais également d’autres constructions jinja2 comme:

  • Des if : {% if nginx_state == 'present' %}...{% endif %}.
  • Des boucles for : {% for host in groups['appserver'] %}...{% endfor %}.
  • Des inclusions de templates {% include 'autre_fichier_template.j2' %}

Imports et includes

Il est possible d’importer le contenu d’autres fichiers dans un playbook:

  • import_tasks: importe une liste de tâches (atomiques)
  • import_playbook: importe une liste de play contenus dans un playbook.

Les deux instructions précédentes désignent un import statique qui est résolu avant l’exécution.

En général, on utilise import_* pour améliorer la lisibilité de notre dépôt.

Au contraire, include_tasks permet d’intégrer une liste de tâches dynamiquement pendant l’exécution. En général, on utilise include_* pour décider quelles tâches, quelles variables ou quels rôles seront inclus au run d’un playbook.

Par exemple :

vars:
  apps:
    - app1
    - app2
    - app3

tasks:
  - include_tasks: install_app.yml
    loop: "{{ apps }}"

Ce code indique à Ansible d’exécuter une série de tâches pour chaque application de la liste. On pourrait remplacer cette liste par une liste dynamique. Comme le nombre d’imports ne peut pas facilement être connu à l’avance on doit utiliser include_tasks.

Documentation additionnelle :

Debugger un playbook

Avec Ansible on dispose d’au moins trois manières de debugger un playbook :

  • Rendre la sortie verbeuse (mode debug) avec -vvv.

  • Utiliser une tâche avec le module debug : debug msg="{{ mavariable }}".

  • Utiliser la directive debugger: always ou on_failed à ajouter à la fin d’une tâche. L’exécution s’arrête alors après l’exécution de cette tâche et propose un interpreteur de debug.

Les commandes et l’usage du debugger sont décrits dans la documentation: https://docs.ansible.com/ansible/latest/user_guide/playbooks_debugger.html

Les 7 commandes de debug dans Ansible

Command Shortcut Action
print p Print information about the task
task.args[key] = value Update module arguments
task_vars[key] = value Update task variables (you must update_task next)
update_task u Recreate a task with updated task variables
redo r Run the task again
continue c Continue executing, starting with the next task
quit q Quit the debugger

Cours 4 - Organiser un projet

Organisation d’un dépôt de code Ansible

Voici, extrait de la documentation Ansible sur les “Best Practices”, l’une des organisations de référence d’un projet ansible de configuration d’une infrastructure :

production                # inventory file for production servers
staging                   # inventory file for staging environment

group_vars/
   group1.yml             # here we assign variables to particular groups
   group2.yml
host_vars/
   hostname1.yml          # here we assign variables to particular systems
   hostname2.yml

library/                  # if any custom modules, put them here (optional)
module_utils/             # if any custom module_utils to support modules, put them here (optional)
filter_plugins/           # if any custom filter plugins, put them here (optional)

site.yml                  # master playbook
webservers.yml            # playbook for webserver tier
dbservers.yml             # playbook for dbserver tier

roles/
    common/               # this hierarchy represents a "role"
        ...               # role code

    webtier/              # same kind of structure as "common" was above, done for the webtier role
    monitoring/           # ""
    fooapp/               # ""

Plusieurs remarques:

  • Chaque environnement (staging, production) dispose d’un inventaire ce qui permet de préciser à runtime quel environnement cibler avec l’option --inventory production.
  • Chaque groupe de serveurs (tier) dispose de son playbook
    • qui s’applique sur le groupe en question.
    • éventuellement définit quelques variables spécifiques (mais il vaut mieux les mettre dans l’inventaire ou les dossiers cf suite).
    • Idéalement contient un minimum de tâches et plutôt des roles (ie des tâches rangées dans une sorte de module)
  • Pour limiter la taille de l’inventaire principal on range les variables communes dans des dossiers group_vars et host_vars. On met à l’intérieur un fichier <nom_du_groupe>.yml qui contient un dictionnaire de variables.
  • On cherche à modulariser au maximum la configuration dans des roles c’est à dire des modules rendus génériques et specifique à un objectif de configuration.
  • Ce modèle d’organisation correspond plutôt à la configuration de base d’une infrastructure (playbooks à exécuter régulièrement) qu’à l’usage de playbooks ponctuels comme pour le déploiement. Mais, bien sur, on peut ajouter un dossier playbooks ou operations pour certaines opérations ponctuelles. (cf cours 4)
  • Si les modules de Ansible (complétés par les commandes bash) ne suffisent pas on peut développer ses propre modules ansible.
    • Il s’agit de programmes python plus ou moins complexes
    • On les range alors dans le dossier library du projet ou d’un role et on le précise éventuellement dans ansible.cfg.
  • Observons le role Common : il est utilisé ici pour rassembler les taches de base des communes à toutes les machines. Par exemple s’assurer que les clés ssh de l’équipe sont présentes, que les dépots spécifiques sont présents etc.

Roles Ansible

Objectif:

  • Découper les tâches de configuration en sous ensembles réutilisables (une suite d’étapes de configuration).

  • Ansible est une sorte de langage de programmation et l’intéret du code est de pouvoir créer des fonction regroupées en librairies et les composer. Les roles sont les “librairies/fonction” ansible en quelque sorte.

  • Comme une fonction un role prend généralement des paramètres qui permettent de personnaliser son comportement.

  • Tout le nécessaire doit y être (fichiers de configurations, archives et binaires à déployer, modules personnels dans library etc.)

  • Remarque ne pas confondre modules et roles : file est un module geerlingguy.docker est un role. On doit écrire des roles pour coder correctement en Ansible, on peut écrire des modules mais c’est largement facultatif car la plupart des actions existent déjà.

  • Présentation d’un exemple de role : https://github.com/geerlingguy/ansible-role-docker

    • Dans la philosophie Ansible on recherche la généricité des roles. On cherche à ajouter des paramètres pour que le rôle s’adapte à différents cas (comme notre playbook flask app).
    • Une bonne pratique: préfixer le nom des paramètres par le nom du rôle exemple docker_edition.
    • Cependant la généricité est nécessaire quand on veut distribuer le role ou construire des outils spécifiques qui serve à plus endroit de l’infrastructure mais elle augmente la complexité.
    • Donc pour les roles internes on privilégie la simplicité.
    • Les roles contiennent idéalement un fichier README en décrire l’usage et un fichier meta/main.yml qui décrit la compatibilité et les dépendanice en plus de la licence et l’auteur.
    • Il peuvent idéalement être versionnés dans des dépots à part et installé avec ansible-galaxy

Structure d’un rôle

Un rôle est un dossier avec des sous dossiers qui répondent à une convention de nommage précise (contrairement à l’organisation d’un projet Ansible, qui peut être plus chaotique), généralement quelque chose comme :

ou encore :

roles/
    mediawiki/            # le nom du rôle
        tasks/            #
            main.yml      #  <-- fichier de tasks principal
            autre.yml     #  <-- fichier(s) de tasks en plus
        handlers/         #
            main.yml      #  <-- handlers file
        templates/        #  <-- files for use with the template resource
            ntp.conf.j2   #  <------- templates end in .j2
        files/            #
            foo.sh        #  <-- script files for use with the script resource
        defaults/         #
            main.yml      #  <-- default lower priority variables for this role

Voici la version exhaustive :

roles/
    requirements.yml      # la liste des rôles nécessaires et comment les récupérer
    mediawiki/            # le nom du rôle
        tasks/            #
            main.yml      #  <-- tasks file can include smaller files if warranted
        handlers/         #
            main.yml      #  <-- handlers file
        templates/        #  <-- files for use with the template resource
            ntp.conf.j2   #  <------- templates end in .j2
        files/            #
            foo.sh        #  <-- script files for use with the script resource
        vars/             #
            main.yml      #  <-- variables associated with this role
        defaults/         #
            main.yml      #  <-- default lower priority variables for this role
        meta/             #
            main.yml      #  <-- role dependencies
        molecule/         # pour le test du rôle
            check.yml
            converge.yml
            idempotent.yml
            verify.yml
        # Plus rare :
        library/          # roles can also include custom modules
        module_utils/     # roles can also include custom module_utils
        lookup_plugins/

On constate que les noms des sous dossiers correspondent souvent à des sections du playbook. En fait le principe de base est d’extraire les différentes listes de taches ou de variables dans des sous-dossier

  • Remarque : les fichier de liste doivent nécessairement s’appeler main.yml" (pas très intuitif)

  • Remarque2 : main.yml peut en revanche importer d’autre fichiers aux noms personnalisés (exp role docker de geerlingguy)

  • Le dossier defaults contient les valeurs par défaut des paramètres du role. Ces valeurs ne sont jamais prioritaires (elles sont écrasées par n’importe quelle redéfinition)

  • Le fichier meta/main.yml est facultatif mais conseillé et contient des informations sur le role

    • auteur
    • license
    • compatibilité
    • version
    • dépendances à d’autres roles.
  • Le dossier files contient les fichiers qui ne sont pas des templates (pour les module copy ou sync, script etc).

Ansible Galaxy

C’est le store de roles officiel d’Ansible : https://galaxy.ansible.com/

C’est également le nom d’une commande ansible-galaxy qui permet d’installer des roles et leurs dépendances depuis internet. Un sorte de gestionnaire de paquet pour ansible.

Elle est utilisée généralement sour la forme ansible-galaxy install -r roles/requirements.yml -p roles ou plus simplement ansible-galaxy install <role> mais installe dans /etc/ansible/roles.

Tous les rôles ansible sont communautaires (pas de roles officiels) et généralement stockés sur github.

Mais on peut voir la popularité la qualité et les tests qui garantissement la plus ou moins grande fiabilité du role

Il existe des roles pour installer un peu n’importe quelle application serveur courante aujourd’hui. Passez du temps à explorer le web avant de développer quelque chose avec Ansible

Installer des roles avec requirements.yml

Conventionnellement on utilise un fichier requirements.yml situé dans roles pour décrire la liste des roles nécessaires à un projet.

- src: geerlingguy.repo-epel
- src: geerlingguy.haproxy
- src: geerlingguy.docke
# from GitHub, overriding the name and specifying a specific tag
- src: https://github.com/bennojoy/nginx
  version: master
  name: nginx_role
  • Ensuite pour les installer on lance: ansible-galaxy install -r roles/requirements.yml -p roles.

Dépendances entre rôles

Même si cela a un coût quant à la clarté d’exécution, chaque fois avec un playbook on peut laisser la cascade de dépendances mettre nos serveurs dans un état complexe désiré Si un role dépend d’autres roles, les dépendances sont décrite dans le fichier meta/main.yml comme suit

---
dependencies:
  - role: common
    vars:
      some_parameter: 3
  - role: apache
    vars:
      apache_port: 80
  - role: postgres
    vars:
      dbname: blarg
      other_parameter: 12

Les dépendances sont exécutées automatiquement avant l’execution du role en question. Ce méchanisme permet de créer des automatisation bien organisées avec une forme de composition de roles simple pour créer des roles plus complexe : plutôt que de lancer les rôles à chaque fois avec un playbook on peut laisser la cascade de dépendances mettre nos serveurs dans un état complexe désiré.

Tester les roles avec Molecule et le Test Driven Development

Pour des rôles fiables il est conseillé d’utiliser l’outil de testing molecule dès la création d’un nouveau rôle pour effectuer des tests unitaire dessus dans un environnement virtuel comme Docker.

On crée différents types de scénarios, même si celui par défaut par Molecule permet déjà d’avoir un bon test du fonctionnement de notre rôle, en couvrant differents cas dès le début :

  • check.yml
  • converge.yml
  • idempotent.yml
  • verify.yml

TP3 - Structurer le projet avec des rôles

Pour ce TP on va réutiliser soit le dossier du TP2, soit la solution du TP2 : git clone https://github.com/Uptime-Formation/ansible-tp-solutions -b tp2_correction

Ajouter une installation MySQL simple à une de vos machines avec un rôle trouvé sur Internet

  • Créez à la racine du projet le dossier roles dans lequel seront rangés tous les rôles (c’est une convention ansible à respecter).

  • Les rôles sont sur https://galaxy.ansible.com/, mais difficilement trouvables… cherchons sur GitHub l’adresse du dépôt Git avec le nom du rôle mysql de geerlingguy. Il s’agit de l’auteur d’un livre de référence “Ansible for DevOps” et de nombreux rôles de références.

  • Pour décrire les rôles nécessaires pour notre projet il faut créer un fichier requirements.yml contenant la liste de ces rôles. Ce fichier peut être n’importe où mais il faut généralement le mettre directement dans le dossier roles (autre convention).

  • Ajoutez à l’intérieur du fichier:

- src: <adresse_du_depot_git_du_role_mysql>
  name: geerlingguy.mysql
  • Pour installez le rôle lancez ensuite ansible-galaxy install -r roles/requirements.yml -p roles.

  • Facultatif : Ajoutez la ligne geerlingguy.* au fichier .gitignore pour ne pas ajouter les roles externes à votre dépot git.

  • Pour installer notre base de données, ajoutez un playbook dbservers.yml appliqué au groupe dbservers avec juste une section:

    ...
    roles:
        - <nom_role>
  • Faire un playbook principal site.yml (le playbook principal par convention) qui importe juste les deux playbooks appservers.yml et dbservers.yml avec import_playbook.

  • Lancer la configuration de toute l’infra avec ce playbook.

  • Dans votre playbook dbservers.yml et en lisant le mode d’emploi du rôle (ou bien le fichier defaults/main.yml), écrasez certaines variables par défaut du rôle par des variables personnalisées. Relancez votre playbook avec --diff (et éventuellement --check) pour observer les différences.

Transformer notre playbook en role

Pour ce TP on va réutiliser soit le dossier du TP2, soit la solution du TP2 : git clone https://github.com/Uptime-Formation/ansible-tp-solutions -b tp2_correction

  • Si ce n’est pas fait, créez à la racine du projet le dossier roles dans lequel seront rangés tous les roles (c’est une convention ansible à respecter).
  • Créer un dossier flaskapp dans roles.
  • Ajoutez à l’intérieur l’arborescence:
flaskapp
├── defaults
│   └── main.yml
├── handlers
│   └── main.yml
├── tasks
│   ├── deploy_app_tasks.yml
│   └── main.yml
└── templates
    ├── app.service.j2
    └── nginx.conf.j2
  • Les templates et les listes de handlers/tasks sont a mettre dans les fichiers correspondants (voir plus bas)

  • Le fichier defaults/main.yml permet de définir des valeurs par défaut pour les variables du role.

  • Si vous avez fait l’amélioration 2 du TP2 “Rendre le playbook dynamique avec une boucle”

    • Mettez à l’intérieur une application par défaut dans la variable flask_apps
flask_apps:
  - name: defaultflask
    domain: defaultflask.test
    repository: https://github.com/e-lie/flask_hello_ansible.git
    version: master
    user: defaultflask
  • Sinon :
    • Mettez à l’intérieur des valeurs par défaut pour la variable app :
app:
  name: defaultflask
  domain: defaultflask.test
  repository: https://github.com/e-lie/flask_hello_ansible.git
  version: master
  user: defaultflask

Ces valeurs seront écrasées par celles fournies dans le dossier group_vars (la liste de deux applications du TP2), ou bien celles fournies dans le playbook (si vous n’avez pas déplacé la variable flask_apps). Elle est présente pour éviter que le rôle plante en l’absence de variable (valeurs de fallback).

Découpage des tasks du rôle

Occupons-nous maintenant de la liste de tâches de notre rôle. Une règle simple : il n’y a jamais de playbooks dans un rôle : il n’y a que des listes de tâches.

L’idée est la suivante :

  • on veut avoir un playbook final qui n’aie que des variables (section vars:), un groupe de hosts: et l’invocation de notre rôle

  • dans le rôle dans le dossier tasks on veut avoir deux fichiers :

    • un main.yml qui sert à invoquer une “boucle principale” (avec include_tasks: et loop:)
    • …et la liste de tasks à lancer pour chaque item de la liste flask_apps
  • Copiez les tâches (juste la liste de tirets sans l’intitulé de section tasks:) contenues dans le playbook flask_deploy.yml dans le fichier tasks/main.yml.

  • De la même façon copiez le handler dans handlers/main.yml sans l’intitulé handlers:.

  • Copiez également le fichier deploy_flask_tasks.yml dans le dossier tasks.

  • Déplacez vos deux fichiers de template dans le dossier templates du role (et non celui à la racine que vous pouvez supprimer).

  • Pour appeler notre nouveau role, supprimez les sections tasks: et handlers: du playbook appservers.yml et ajoutez à la place:

  roles:
    - flaskapp
  • Votre role est prêt : lancez appservers.yml et debuggez le résultat le cas échéant.

Facultatif: rendre le rôle compatible avec le mode --check

  • Ajouter une app dans la variable flask_apps et lancer le playbook avec --check. Que se passe-t-il ? Pourquoi ?
  • ajoutez une instruction ignore_errors: {{ ansible_check_mode }} au bon endroit. Re-testons.

Facultatif: Ajouter un paramètre d’exécution à notre rôle pour mettre à jour l’application

Facultatif :

Solution

  • Pour la solution, clonons le dépôt via cette commande :
cd # Pour revenir dans notre dossier home
git clone https://github.com/Uptime-Formation/ansible-tp-solutions -b tp3_correction tp3_correction

Vous pouvez également consulter la solution directement sur le site de Github : https://github.com/Uptime-Formation/ansible-tp-solutions/tree/tp3_correction

Bonus 1

Essayez différents exemples de projets de Jeff Geerling accessibles sur Github à l’adresse https://github.com/geerlingguy/ansible-for-devops.

Bonus 2 - Unit testing de rôle avec Molecule

Pour des rôles fiables il est conseillé d’utiliser l’outil de testing molecule dès la création d’un nouveau rôle pour effectuer des tests unitaires dessus dans un environnement virtuel comme Docker.

On peut créer des scénarios :

  • check.yml

  • converge.yml

  • idempotent.yml

  • verify.yml

  • on peux écrire ces tests avec ansible qui vérifie tout tâche par tâche écrite originalement

  • ou alors avec testinfra la lib python spécialisée en collecte de facts os

  • Il y a plein de drivers pas fonctionnels sauf Docker

  • Pour des cas compliqués, le driver Hetzner Cloud est le meilleur driver VPS

Documentation : https://molecule.readthedocs.io/en/latest/

TP4 - Automatisation du déploiement avec Gitlab CI

Versionner le projet et utiliser la CI Gitlab avec Ansible pour automatiser le déploiement

  • Créez un compte sur la forge logicielle gitlab.com et créez un projet (dépôt) public.

  • Affichez et copiez cat ~/.ssh/id_ed25519.pub.

  • Dans (User) Settings > SSH Keys, collez votre clé publique copiée dans la quesiton précédente.

  • Suivez les instructions pour pousser le code du projet Ansible sur ce dépôt.

  • Dans le menu à gauche sur la page de votre projet Gitlab, cliquez sur Build > Pipeline Editor. Cet éditeur permet d’éditer directement dans le navigateur le fichier .gitlab-ci.yml et de commiter vos modification directement dans des branches sur le serveur.

  • Ajoutez à la racine du projet un fichier .gitlab-ci.yml avec à l’intérieur:

image:
  # This linux container (docker) we will be used for our pipeline : ubuntu bionic with ansible preinstalled in it
  name: williamyeh/ansible:ubuntu18.04

variables:
    ANSIBLE_CONFIG: $CI_PROJECT_DIR/ansible.cfg

deploy:
  # The 3 lines after this are used activate the pipeline only when the master branch changes
  only:
    refs:
      - master
  script:
    - ansible --version

En poussant du nouveau code dans master ou en mergant dans master les jobs sont automatiquement lancés via une nouvelle pipeline : c’est le principe de la CI/CD Gitlab. only: refs: master sert justement à indiquer de limiter l’exécution des pipelines à la branche master.

  • Cliquez sur commit dans le web IDE et cochez merge to master branch. Une fois validé votre code déclenche donc directement une exécution du pipeline.

  • Vous pouvez retrouver tout l’historique de l’exécution des pipelines dans la Section CI / CD > Jobs rendez vous dans cette section pour observer le résultat de la dernière exécution.

  • Notre pipeline nous permet uniquement de vérifier la bonne disponibilité d’ansible.

  • Elle est basée sur une (vieille) image docker contenant Ansible pour ensuite executer notre projet d’Iinfra as Code.

Alternative 1 : se connecter directement depuis le runner aux serveurs cible

  • Créons un runner Gitlab de type shell et installons-le dans notre lab.

  • Faisons en sorte que c’est ce runner qui se chargera de l’exécution des jobs grâce aux tags.

  • Remplacez ansible --version par un ping de toutes les machines.

  • Relancez la pipeline en committant (et en poussant) vos modifications dans master.

  • Allez observer le job en cours d’exécution.

  • Enfin lançons notre playbook principal en remplaçant la commande ansible précédente dans la pipeline et committant

Alternative 2 : un déploiement léger et sécurisé avec ansible-pull

https://blog.octo.com/ansible-pull-killer-feature/

  • Avec l’aide de cet article et de l’option --url, mettre en place un déploiement “inversé” avec ansible-pull. Il va falloir exécuter un playbook qui s’applique sur localhost ou sur notre hostname (vnc-votreprenom)
  • En mettant en place un cron (ou un timer systemd), lancez ce déploiement toutes les 5min, et observez dans les logs.

Alternative 3 : un déploiement plus sécurisé avec un webhook

Création du script d’exécution et logs dans Ansible

  • à la racine du dépôt Ansible, créez un script Bash nommé ansible-run.sh, copiez et collez le contenu suivant dans le fichier ansible-run.sh et remplacez la commande par un vrai playbook situé dans le même dossier :
#!/bin/bash
ansible-playbook site.yml --diff
  • rendez le script exécutable avec chmod +x ansible-run.sh

Pour suivre ce qu’il se passe, ajoutez la ligne suivante dans votre fichier ansible.cfg pour spécifier le chemin du fichier de logs (ansible_log.txt en l’occurrence) :

log_path=./ansible_log.txt
  • dans un terminal, faites ./ansible-run.sh et observez les logs pour tester votre script de déploiement.

Installation et configuration du Webhook

Sur votre serveur de déploiement (celui avec le projet Ansible), installez le paquet webhook en utilisant la commande suivante :

sudo apt install webhook

Ensuite, créons un fichier de configuration pour le webhook.

  • Avec nano ou vi par exemple, faites sudo nano /etc/webhook.conf pour créer le fichier puis modifions-le avec le contenu suivant en adaptant la partie /home/formateur/projet-ansible avec le chemin de votre projet, puis enregistrez et quittez le fichier (pour nano, en appuyant sur Ctrl + X, suivi de Y, puis appuyez sur Entrée) :
[
  {
    "id": "redeploy-webhook",
    "command-working-directory": "/home/formateur/projet-ansible",
    "execute-command": "/home/formateur/projet-ansible/ansible-run.sh",
    "include-command-output-in-response": true,
  }
]

Lancement et test du webhook

Lancez le webhook en utilisant la commande suivante dans un nouveau terminal (si le terminal se ferme, le webhook s’arrêtera) :

/usr/bin/webhook -nopanic -hooks /etc/webhook.conf -port 9999 -verbose

Pour tester le webhook, ouvrez simplement un navigateur web et accédez à l’URL suivante, en remplaçant localhost par le nom de votre domaine ou l’adresse IP de votre serveur si nécessaire : http://localhost:9999/hooks/redeploy-webhook

Le webhook exécutera le script ansible-run.sh, qui lancera votre playbook Ansible.

Le webhook attend que le playbook finisse, laissons la page se charger dans le navigateur, ce qui peut prendre du temps. Ensuite, il affichera le retour de la sortie standard (ou une erreur).

Faites un tail -f ansible_log.txt pour suivre le playbook le temps qu’il se termine, puis observer le retour de la requête HTTP dans votre navigateur.

Intégration à Gitlab CI

Dans un fichier .gitlab-ci.yml vous n’avez plus qu’à appeler curl http://votredomaine:9999/hooks/redeploy-webhook pour déclencher l’exécution de votre playbook Ansible en réponse à une requête depuis les serveurs de Gitlab.

deploy:
  # The 3 lines after this are used activate the pipeline only when the master branch changes
  only:
    refs:
      - master
  script:
    - curl --fail http://hadrien.lab.doxx.fr:9999/hooks/redeploy-webhook

Cette configuration est bien plus sécurisée, même si en production nous protégerions le webhook avec un mot de passe (token) pour éviter que le webhook soit déclenché abusivement si quelqu’un en découvrait l’URL.

--fail permet de convertir une erreur HTTP (500) en code de sortie d’erreur Bash pour la CI.

On pourrait aussi variabiliser le webhook pour faire passer des paramètres à notre script ansible-run.sh.

Bonus : Créez une planification pour le rolling upgrade de notre application

  • Dans Build > Pipeline schedules ajoutez un job planifié toutes les heures (fréquence maximum sur gitlab.com) (en production toutes les nuits serait plus adapté) : * * * * * *
  • Observez le résultat.
  • Supprimez le job

Pour Codeberg / ForgeJo

  1. Ajouter une clé SSH (éventuellement la générer avec ssh-keygen) publique à Gitlab ou Codeberg
  1. Enregistrer un “runner” : https://docs.codeberg.org/ci/actions/#running-on-host-machine

    1. Actions > Exécuteurs > et copier le token

wget -O forgejo-runner https://code.forgejo.org/forgejo/runner/releases/download/v3.3.0/forgejo-runner-3.3.0-linux-amd64

chmod +x forgejo-runner

./forgejo-runner register --instance https://codeberg.org et compléter
  1. Installer Docker :
curl https://get.docker.com | sh 

sudo usermod -a -G docker $USER 

et rebooter : sudo reboot

  1. Lancer le runner dans un terminal : ./forgejo-runner daemon
  1. Pour Codeberg : activer les Actions ForgeJo dans les paramètres du dépôt
  1. Adapter le fichier de CI pour que Ansible lance nos playbooks

B. Pour Codeberg / Forgejo, repartir de ce template à mettre dans .forgejo/workflows/ansible.yml

on: [push]
jobs:
  test:
    runs-on: docker
          container:
              image: williamyeh/ansible:ubuntu18.04
    steps:
      - uses: actions/checkout@v4
      - run: ansible-playbook site.yml 

Cours 5 - Sécurité et Cloud

Sécurité

Les problématiques de sécurité Linux ne sont pas résolues magiquement par Ansible. Tout le travail de réflexion et de sécurisation reste identique mais peut comme le reste être mieux contrôlé grace à l’approche déclarative de l’infrastructure as code.

Si cette problématique des liens entre Ansible et sécurité vous intéresse : Security automation with Ansible

Il est à noter tout de même qu’Ansible est généralement apprécié d’un point de vue sécurité car il n’augmente pas (vraiment) la surface d’attaque de vos infrastructures : il est basé sur SSH qui est éprouvé et ne nécessite généralement pas de réorganisation des infrastructures.

Pour les cas plus spécifiques et si vous voulez éviter SSH, Ansible est relativement agnostique du mode de connexion grâce aux plugins de connexion (voir ci-dessous).

Authentification et SSH

Il faut idéalement éviter de créer un seul compte Ansible de connexion pour toutes les machines :

  • difficile à bouger : cela crée un Single Point of Failure impossible à changer
  • responsabilité des connexions pas auditable (auth.log + syslog)

Il faut utiliser comme nous avons fait dans les TP des logins SSH avec les utilisateurs humain réels des machines et des clés SSH. C’est à dire le même modèle d’authentification que l’administration traditionnelle.

On peut d’ailleurs avec Ansible créer des playbooks pour le roulement régulier des clés publiques et certificats.

Les autres modes de connexion

Le mode de connexion par défaut de Ansible est SSH, cependant il est possible d’utiliser de nombreux autres modes de connexion spécifiques :

  • Pour afficher la liste des plugins disponibles lancez ansible-doc -t connection -l.

  • Une connexion courante est ansible_connection=local qui permet de configurer la machine locale sans avoir besoin d’installer un serveur SSH.

  • Citons également les connexions ansible_connection=docker et ansible_connection=incus pour configurer des conteneurs Linux, ainsi que ansible_connection=winrm pour les serveurs Windows

  • Pour débugger les connexions et diagnotiquer leur sécurité on peut afficher les détails de chaque connexion Ansible avec le mode de verbosité maximal (network) en utilisant le paramètre -vvvv.

Variables et secrets

Le principal risque de sécurité lié à Ansible comme avec Docker et l’IaC en général consiste à laisser traîner des secrets (mots de passe, identité de clients, tokens d’API, secrets de chiffrement, etc.) dans le dépôt de code, ou sur les serveurs (moins problématique).

Attention : les dépôts Git peuvent cacher des secrets dans leur historique. Pour chercher et nettoyer un secret dans un dépôt l’outil le plus courant est BFG : https://rtyley.github.io/bfg-repo-cleaner/ Il existe aussi des produits open source de scan de secrets comme Gitleaks : https://github.com/gitleaks/gitleaks

Ansible Vault

Pour éviter de divulguer des secrets par inadvertance, il est possible de gérer les secrets avec des variables d’environnement ou avec un fichier variable externe au projet qui échappera au versionning Git, mais ce n’est pas idéal.

Via les plugins de lookup (ansible-doc -t lookup), on peut aussi interroger de nombreux produits et bases de données pour extraire des secrets d’une solution spécifique comme Hashicorp Vault.

Ansible intègre un trousseau de secret appelé Ansible Vault, qui permet de chiffrer des valeurs variables par variables ou des fichiers complets (recommandé). Les valeurs stockées dans le trousseau sont déchiffrées à l’exécution après déverrouillage du trousseau.

  • ansible-vault create /var/secrets.yml
  • ansible-vault edit /var/secrets.yml ouvre $EDITOR pour changer le fichier de variables
  • ansible-vault encrypt_file /vars/secrets.yml pour chiffrer un fichier existant
  • ansible-vault encrypt_string monmotdepasse permet de chiffrer une valeur avec un mot de passe. le résultat peut être ensuite collé dans un fichier de variables par ailleurs en clair.

Pour déchiffrer il est ensuite nécessaire d’ajouter l’option --ask-vault-pass au moment de l’exécution de ansible ou ansible-playbook

Désactiver le logging des informations sensibles

Ansible propose une directive no_log: yes qui permet de désactiver l’affichage des valeurs d’entrée et de sortie d’une tâche.

Il est ainsi possible de limiter la prolifération de données sensibles dans les logs qui enregistrent le résultat des playbooks Ansible.

Ansible dans le cloud

L’automatisation Ansible fait d’autant plus sens dans un environnement d’infrastructure dynamique :

  • L’agrandissement horizontal implique de résinstaller régulièrement des machines identiques
  • L’automatisation et la gestion des configurations permet de mieux contrôler des environnements de plus en plus complexes.

Il existe de nombreuses solutions pour intégrer Ansible avec les principaux providers de cloud (modules Ansible, plugins d’API, intégration avec d’autre outils d’IaC Cloud comme Terraform ou Cloudformation).

Inventaires dynamiques

Les inventaires que nous avons utilisés jusqu’ici impliquent d’affecter à la main les adresses IP des différents noeuds de notre infrastructure. Cela devient vite ingérable.

La solution Ansible pour ne pas gérer les IP et les groupes à la main est appelée inventaire dynamique ou inventory plugin. Un inventaire dynamique est simplement un programme qui renvoie un JSON respectant le format d’inventaire JSON ansible, généralement en contactant l’API du cloud provider ou une autre source.

$ ./inventory_terraform.py
{
  "_meta": {
    "hostvars": {
      "balancer0": {
        "ansible_host": "104.248.194.100"
      },
      "balancer1": {
        "ansible_host": "104.248.204.222"
      },
      "awx0": {
        "ansible_host": "104.248.204.202"
      },
      "appserver0": {
        "ansible_host": "104.248.202.47"
      }
    }
  },
  "all": {
    "children": [],
    "hosts": [
      "appserver0",
      "awx0",
      "balancer0",
      "balancer1"
    ],
    "vars": {}
  },
  "appservers": {
    "children": [],
    "hosts": [
      "balancer0",
      "balancer1"
    ],
    "vars": {}
  },
  "awxnodes": {
    "children": [],
    "hosts": [
      "awx0"
    ],
    "vars": {}
  },
  "balancers": {
    "children": [],
    "hosts": [
      "appserver0"
    ],
    "vars": {}
  }
}%  

On peut ensuite appeler ansible-playbook en utilisant ce programme plutôt qu’un fichier statique d’inventaire: ansible-playbook -i inventory_terraform.py configuration.yml

Étendre et intégrer Ansible

La bonne pratique : utiliser un plugin d’inventaire pour l’alimenter

Bonne pratique : Normalement l’information de configuration Ansible doit provenir au maximum de l’inventaire. Ceci est conforme à l’orientation plutôt déclarative d’Ansible et à son exécution descendante (master -> nodes). La méthode à privilégier pour intégrer Ansible à des sources d’information existantes est donc d’utiliser ou développer un plugin d’inventaire.

https://docs.ansible.com/ansible/latest/plugins/inventory.html

La liste : ansible-doc -t inventory -l

On peut cependant alimenter le dictionnaire de variables Ansible au fur et à mesure de l’exécution, en particulier grâce à la directive register et au module set_fact.

Exemple:


- name: 'get postfix default configuration'
  command: 'postconf -d'
  register: postconf_result
  changed_when: false

# the answer of the command give a list of lines such as:
# "key = value" or "key =" when the value is null
- name: 'set postfix default configuration as fact'
  set_fact:
    postconf_d: >
            {{ postconf_d | combine(dict([ item.partition('=')[::2]map'trim') ])) }}
  loop: postconf_result.stdout_lines

On peut explorer plus facilement la hiérarchie d’un inventaire statique ou dynamique avec la commande:

ansible-inventory --inventory <inventory> --graph

Principaux types de plugins possibles pour étendre Ansible

Ansible et Terraform

Voir TP.

Ansible et Kubernetes

  • pour déployer un cluster initialement, avec kubespray
  • pour ajouter et supprimer des ressources K8S avec le module community.kubernetes.k8s

Exécuter Ansible en production : les stratégies d’exécution

https://docs.ansible.com/ansible/latest/user_guide/playbooks_strategies.html

Serveur pour exécuter Ansible dans une équipe

  • AWX/Tower

    • Serveur officiel RedHat et sa version open source
    • assez lourd et installable uniquement dans Kubernetes
    • très puissant
    • plein de plugins d’intégration
    • logging des exécutions assez optimal
  • Jenkins

    • Un peu vieux mais très versatile
    • un bon plugin Ansible
    • gestion de ansible-vault et des credentials
  • Rundeck

    • une alternative à AWX/Ansible Tower assez populaire et plus légère
  • Semaphore

    • une alternative à AWX/Ansible Tower légère et jolie
  • Gitlab

    • faisable mais pas très bien intégré
  • Un simple serveur avec Ansible d’installé

  • Depuis la machine de chaque adminsys, en clonant les bonnes versions des dépôts Git, en récupérant un Vault. Il faudra réfléchir à pousser les logs de façon centralisée

Exemple d’installation complexe

TP5 - Simuler un load balancer

Infrastructure multi-tier avec load balancer

Cloner le projet modèle

Pour configurer notre infrastructure:

  • Installez les roles avec ansible-galaxy install -r roles/requirements.yml -p roles.

  • complétez l’inventaire statique (inventory.cfg)

  • changer dans ansible.cfg l’inventaire en ./inventory.cfg

  • Lancez le playbook global site.yml

  • Utilisez la commande ansible-inventory --graph pour afficher l’arbre des groupes et machines de votre inventaire

  • Utilisez-la de même pour récupérer l’IP du balancer0 (ou balancer1) avec : ansible-inventory --host=balancer0

  • Ajoutez hello.test dans /etc/hosts en pointant vers l’ip de balancer0.

  • Chargez la page hello.test.

  • Observons ensemble l’organisation du code Ansible de notre projet.

    • Nous avons rajouté à notre infrastructure un loadbalancer installé à l’aide du fichier balancers.yml
    • Le playbook upgrade_apps.yml permet de mettre à jour l’application en respectant sa haute disponibilité. Il s’agit d’une opération d’orchestration simple en utilisant les 3 (+ 1) serveurs de notre infrastructure.
    • Cette opération utilise en particulier serial qui permet de d’exécuter séquentiellement un play sur une fraction des serveurs d’un groupe (ici 1 à la fois parmi les 3).
    • Notez également l’usage de delegate qui permet d’exécuter une tâche sur une autre machine que le groupe initialement ciblé. Cette directive est au coeur des possibilités d’orchestration Ansible en ce qu’elle permet de contacter un autre serveur (déplacement latéral et non pas master -> node ) pour récupérer son état ou effectuer une modification avant de continuer l’exécution et donc de coordonner des opérations.
    • notez également le playbook manually_exclude_backend.yml qui permet de sortir un backend applicatif du pool. Il s’utilise avec des vars prompts (questionnaire) et/ou des variables en ligne de commande.
  • Désactivez le noeud qui vient de vous servir la page en utilisant le playbook manually_exclude_backend.yml en remplissant le prompt. Vous pouvez le réactiver avec -e backend_name=<noeud à réactiver> -e backend_state=enabled.

  • Rechargez la page : vous constatez que c’est l’autre backend qui a pris le relai.

  • Nous allons maintenant mettre à jour avec le playbook d’upgrade, lancez d’abord dans un terminal la commande : while true; do curl hello.test; echo; sleep 1; done

TP6 - Cloud Terraform

Cloner le projet modèle

Infrastructure dans le cloud avec Terraform et Ansible

Token DigitalOcean et clé SSH

  • Pour louer les machines dans le cloud pour ce TP vous aurez besoin d’un compte DigitalOcean : celui du formateur ici mais vous pouvez facilement utiliser le votre. Il faut récupérer les éléments suivant pour utiliser le compte de cloud du formateur:

    • un token d’API DigitalOcean fourni pour la formation. Cela permet de commander des machines auprès de ce provider.
  • Récupérez sur git la paire de clés SSH adaptée :

cd
git clone https://github.com/e-lie/id_ssh_shared.git
chmod 600 id_ssh_shared/id_ssh_shared
  • faites ssh-add ~/id_ssh_shared/id_ssh_shared pour déverrouiller la clé, le mot de passe est trucmuch42

Si vous utilisez votre propre compte

Si vous utilisez votre propre compte, vous aurez besoin d’un token personnel. Pour en créer, allez dans API > Personal access tokens et créez un nouveau token. Copiez bien ce token et collez-le dans un fichier par exemple ~/Bureau/compte_digitalocean.txt (important : détruisez ce token à la fin du TP par sécurité).

  • Copiez votre clé SSH (à créer si nécessaire): cat ~/.ssh/id_ed25519.pub
  • Aller sur DigitalOcean dans la section Account de la sidebar puis Security et ajoutez un nouvelle clé SSH. Notez sa fingerprint dans le fichier précédent.

Installer Terraform et le provider Ansible

Terraform est un outil pour décrire une infrastructure de machines virtuelles et ressources IaaS (infrastructure as a service) et les créer (commander). Il s’intègre en particulier avec du cloud commercial comme AWS ou DigitalOcean, mais peut également créer des machines dans un cluster en interne (on premise) (VMWare par exemple) pour créer un cloud mixte.

Terraform peut s’installer à l’aide d’un dépôt ubuntu/debian. Pour l’installer lancez :

curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=$(dpkg --print-architecture)] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt install terraform
  • Testez l’installation avec terraform --version

Pour pouvoir se connecter à nos VPS, Ansible doit connaître les adresses IP et le mode de connexion SSH de chaque VPS. Il a donc besoin d’un inventaire.

Jusqu’ici nous avons créé un inventaire statique, c’est-à-dire un fichier qui contenait la liste des machines. Nous allons maintenant utiliser un inventaire dynamique : un programme qui permet de récupérer dynamiquement la liste des machines et leurs adresses en contactant une API.

Terraform avec DigitalOcean

  • Le fichier qui décrit les VPS et ressources à créer avec Terraform est provisioner/terraform/main.tf. Nous allons commenter ensemble ce fichier.

  • La documentation pour utiliser Terraform avec DigitalOcean se trouve ici : https://www.terraform.io/docs/providers/do/index.html

Pour que Terraform puisse s’identifier auprès de DigitalOcean nous devons renseigner le token et la fingerprint de clé SSH. Pour cela :

  • copiez le fichier terraform.tfvars.dist et renommez-le en enlevant le .dist

  • collez le token récupéré précédemment dans le fichier de variables terraform.tfvars

  • normalement la clé SSH id_ssh_shared est déjà configurée au niveau de DigitalOcean. On doit préciser le fingerprint 05:f7:18:15:4a:77:3c:4c:86:70:85:aa:cb:18:b7:68. Elle sera donc ajoutée aux VPS que nous allons créer.

  • Maintenant que ce fichier est complété nous pouvons lancer la création de nos VPS :

    • faisons cd provisioner/terraform
    • terraform init permet à Terraform de télécharger les “drivers” nécessaires pour s’interfacer avec notre provider. Cette commande crée un dossier .terraform
    • terraform plan est facultative et permet de calculer et récapituler les créations et modifications de ressources à partir de la description de main.tf
    • terraform apply permet de déclencher la création des ressources.
  • La création prend environ 1 minute.

Maintenant que nous avons des machines dans le cloud nous devons fournir leurs IP à Ansible pour pouvoir les configurer. Pour cela nous allons utiliser un inventaire dynamique.

Inventaire dynamique Terraform

Une bonne intégration entre Ansible et Terraform permet de décrire précisément les liens entre resource terraform et hote ansible ainsi que les groupes de machines ansible. Pour cela notre binder propose de dupliquer les ressources dans main.tf pour créer explicitement les hotes ansible à partir des données dynamiques de terraform.

  • Ouvrons à nouveau le fichier main.tf pour étudier le mapping entre les ressources digitalocean et leur équivalent Ansible.

  • Pour vérifier le fonctionnement de notre inventaire dynamique, allez à la racine du projet et lancez:

source .env
./inventory_terraform.py
  • La seconde commande appelle l’inventaire dynamique et vous renvoie un résultat en JSON décrivant les groupes, variables et adresses IP des machines créées avec Terraform.

  • Complétez le ansible.cfg avec le chemin de l’inventaire dynamique : ./inventory_terraform.py

  • Utilisez la commande ansible-inventory --graph pour afficher l’arbre des groupes et machines de votre inventaire

  • Nous pouvons maintenant tester la connexion avec Ansible directement : ansible all -m ping.

TP7 - Serveur de contrôle AWX + Ansible Vault

Installer AWX ou Semaphore

sudo snap install semaphore
sudo semaphore user add --admin --name "Your Name" --login your_login --email your-email@examaple.com --password your_password

puis se connecter sur le port 3000

Installer Docker

Nécessaire pour Minikube ou Rundeck.

curl https://get.docker.com | sh

Installer AWX

  • Installer k3s :
curl -sfL https://get.k3s.io | sh
alias kubectl="sudo k3s kubectl"
git clone https://github.com/ansible/awx-operator.git
cd awx-operator
git checkout tags/2.7.2

sudo make deploy

Créer un fichier awx-demo.yml :

---
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-demo
spec:
  service_type: nodeport

Puis :

kubectl apply -f awx-demo.yml -n awx

kubectl get secret -n awx awx-demo-admin-password -o jsonpath="{.data.password}" | base64 --decode ; echo

echo "Se connecter en localhost à ce port :"
kubectl get svc -n awx awx-demo-service -o=jsonpath='{.spec.ports[?(@.nodePort)].nodePort}'

Explorer AWX

  • Identifiez vous sur awx avec le login admin et le mot de passe précédemment configuré.

  • Dans la section Modèle de projet, importez votre projet. Un job d’import se lance. Si vous avez mis le fichier requirements.yml dans roles les roles devraient être automatiquement installés.

  • Dans la section credentials, créez un credential de type machine. Dans la section clé privée copiez le contenu du fichier ~/.ssh/id_ssh_tp (ou autre nom) que nous avons configuré comme clé SSH de nos machines. Ajoutez également la passphrase si vous l’avez configuré au moment de la création de cette clé.

  • Créez une ressource inventaire. Créez simplement l’inventaire avec un nom au départ. Une fois créé vous pouvez aller dans la section source et choisir de l’importer depuis le projet, sélectionnez inventory.cfg que nous avons configuré précédemment.

  • Pour tester tout cela vous pouvez lancez une tâche ad-hoc ping depuis la section inventaire en sélectionnant une machine et en cliquant sur le bouton executer.

  • Allez dans la section modèle de job et créez un job en sélectionnant le playbook site.yml.

  • Exécutez ensuite le job en cliquant sur la fusée. Vous vous retrouvez sur la page de job de AWX. La sortie ressemble à celle de la commande mais vous pouvez en plus explorer les taches exécutées en cliquant dessus.

  • Modifiez votre job, dans la section Planifier configurer l’exécution du playbook site.yml toutes les 5 minutes.

  • Allez dans la section planification. Puis visitez l’historique des Jobs.

  • Créons maintenant un workflow qui lance d’abord les playbooks dbservers.yml et appservers.yml puis en cas de réussite le playbook upgrade_apps.yml

  • Voyons ensemble comment configurer un vault Ansible, d’abord dans notre projet Ansible normal en chiffrant le mot de passe utilisé pour le rôle MySQL. Il est d’usage de préfixer ces variables par secret_.

  • Voyons comment déverrouiller ce Vault pour l’utiliser dans AWX en ajoutant des Credentials.

Bonus : réimplémentons le load balancing du TP5 via AWX

Dans un template de tâche ou un workflow AWX, manipulez playbooks/manually_exclude_backend.yml et/ou d’autres playbooks pour réimplementer le scénario du TP5 dans AWX.

TP8 Bonus - Cloud via Incus et générer un inventaire dynamique

Ajouter un provisionneur d’infra maison pour créer les machines automatiquement

Dans notre infra virtuelle, nous avons trois machines dans deux groupes. Quand notre lab d’infra grossit il devient laborieux de créer les machines et affecter les ip à la main. En particulier détruire le lab et le reconstruire est pénible. Nous allons pour cela introduire un playbook de provisionning qui va créer les conteneurs lxd en définissant leur ip à partir de l’inventaire.

  • modifiez l’inventaire comme suit:
[all:vars]
ansible_user=<votre_user>

[appservers]
app1 ansible_host=10.x.y.121 container_image=ubuntu_ansible node_state=started
app2 ansible_host=10.x.y.122 container_image=ubuntu_ansible node_state=started

[dbservers]
db1 ansible_host=10.x.y.131 container_image=ubuntu_ansible node_state=started
  • Remplacez x et y dans l’adresse IP par celle fournies par votre réseau virtuel lxd (faites incus list et copier simple les deux chiffre du milieu des adresses IP)

  • Ajoutez un playbook lxd.yml dans un dossier provisioners/lxd contenant:

- hosts: localhost
  connection: local

  tasks:
    - name: Setup linux containers for the infrastructure simulation
      lxd_container:
        name: "{{ item }}"
        state: "{{ hostvars[item]['node_state'] }}"
        source:
          type: image
          alias: "{{ hostvars[item]['container_image'] }}"
        profiles: ["default"]
        config:
          security.nesting: 'true' 
          security.privileged: 'false' 
        devices:
          # configure network interface
          eth0:
            type: nic
            nictype: bridged
            parent: lxdbr0
            # get ip address from inventory
            ipv4.address: "{{ hostvars[item].ansible_host }}"

        # Comment following line if you installed lxd using apt
        # url: unix:/var/snap/lxd/common/lxd/unix.socket
        wait_for_ipv4_addresses: true
        timeout: 600

      register: containers
      loop: "{{ groups['all'] }}"
    

    # Uncomment following if you want to populate hosts file pour container local hostnames
    # AND launch playbook with --ask-become-pass option

    - name: Config /etc/hosts file accordingly
      become: yes
      lineinfile:
        path: /etc/hosts
        regexp: ".*{{ item }}$"
        line: "{{ hostvars[item].ansible_host }}    {{ item }}"
        state: "present"
      loop: "{{ groups['all'] }}"
  • Etudions le playbook (explication démo).
  • Lancez incus list pour afficher les nouvelles machines de notre infra et vérifier que le serveur de base de données a bien été créé.

TP9 Bonus - Orchestration avancée avec un rollback utilisant block et rescue

Orchestration avancée avec un rollback en utilisant block et rescue

A l’aide de ces pages de la documentation, adaptez les playbooks de https://github.com/Uptime-Formation/exo-ansible-cloud pour gérer le cas où la mise à jour plante (on pourra par exemple tenter une mise à jour en indiquant une branche qui n’existe pas), en décidant de revenir à l’état précédent de l’app et de réactiver l’appserver dans HAProxy.

Liens :

Bibliographie

Ansible

  • Jeff Geerling - Ansible for DevOps - Leanpub
Pour aller plus loin :
  • Keating2017 - Mastering Ansible - Second Edition - Packt
Ansible pour des thématiques sépcifiques
  • Ratan2017 - Practical Network Automation: Leverage the power of Python and Ansible to optimize your network
  • Madhu, Akash2017 - Security automation with Ansible 2
  • https://iac.goffinet.org/ansible-network/
Cheatsheet

Suite Elastic

1 - Découverte de l'écosystème Elastic

Apprendre à nager dans un océan d’évènements et de texte!


  • Ouvrage recommandé : PacktPub - Learning Elastic Stack 6

Dans les épisodes précédents

  • Linux ? on va reparler de tail, grep et des logs
  • HTTP ? on va utiliser une API REST (basé sur HTTP)
  • JSON ? on va utiliser des documents formatés en JSON
  • Les bases de données ?
  • Machines virtuelles ? on va parler un peu à la fin de cluster dans le cloud (c’est compliqué un cluster elasticsearch mais on va surtout voir ça théoriquement)

Rappel

  • L’informatique c’est complexe surtout lorsqu’on est pas familier avec l’environnement. Ça prend quelques temps pour être vraiment à l’aise.
  • Elasticsearch et sa stack c’est particulièrement compliqué ! J’ai essayé d’évité les détails inutiles.
  • Je peux oublier de préciser certaines choses donc arrêtez moi si ce que je dis n’est pas clair.

Intro) La stack ELK : Chercher et analyser les logs de façon centralisée


ELK : Elasticsearch, Logstash, Kibana

  • Elasticsearch : une base de données pour stocker des grandes quantités de documents texte et chercher dedans.

  • Logstash : Un collecteur de logs et autre données pour remplir Elasticsearch.

  • Kibana : Une interface web pratique pour chercher et analyser les données stockées.

La suite Elastic

La suite Elastic, historiquement appelée “ELK”, est une combinaison de plusieurs produits de la société Elastic, qui développe des logiciels :

  • de base de données distribuée (Elasticsearch)
  • de dashboard / d’interface graphique pour explorer des données (Kibana)
  • de logging / monitoring (Logstash et Beats)

Elastic APM

APM est le petit dernier d’Elastic, axé sur le monitoring et le traçage des performances des applications.

L’écosystème Elastic

La société Elastic évolue assez vite et change souvent ses produits. Elle a un business model open core : les fonctionnalités de base sont gratuites et open source, certaines ont une licence gratuites et source ouverte un peu spéciale et sont regroupées dans le “X-Pack” (les fonctionnalités Basic). D’autres fonctionnalités “X-Pack” enfin nécessitent un abonnement “Gold” ou plus.

Le cœur des produits Elastic est composé de Elasticsearch, Kibana (les dashboards et le mode Discover), de Logstash et de Filebeat.

Des bagarres de licence ont conduit d’autres personnes à proposer un fork d’Elasticsearch : OpenSearch (anciennement OpenDistro for Elasticsearch) qui est un fork de la suite Elastic, sponsorisé par Amazon et AWS.

Détails : https://www.elastic.co/fr/subscriptions


Pourquoi ELK ? Pourquoi c’est dans le cursus

  • Gérer une GRANDE quantité de logs sur une infrastructure (entre 5 et des centaines de machines)
  • Les explorer efficacement : un problème difficile vu la quantité (on y reviendra)
  • Un brique important pour avoir des applications distribuées avec un déploiement automatisé #Devops

En résumé

  • On va voir trois choses durant ces deux jours qui peuvent résumer l’intérêt d’ELK:
    • Les logs : pourquoi? comment ? ( quelle est la motivation de ELK )
    • Découvrir elasticsearch et comment chercher dans du texte ? ( la partie principale )
    • Qu’est-ce qu’une infra distribuée moderne ? pourquoi ELK c’est du devops ? ( fin )

Ce qu’on ne va que mentionner rapidement

  • Voir en détail l’installation d’une stack ELK à la main
  • Configurer Logstash ou Elastic APM pour pomper des logs d’une vraie infrastructure
  • Aborder la sécurité de ELK dans sa totalité parce que c’est compliqué (mais c’est important pour faire de vraies installations)

Rapidement, la sécurité dans Elasticsearch

L’écrasante majorité des piratages de Elasticsearch vient simplement de l’exposition sans mot de passe d’instances Elasticsearch sur des adresses IP publiques. Pour s’en rendre compte, on peut demander au moteur de recherche Shodan la liste des serveurs qui ont le port 9200 ouvert sur Internet et qui ne demandent pas d’authentification.

Il y a un modèle RBAC (qui a droit de faire quoi sur le cluster) qui est assez complet et permet aux admins Elasticsearch de mettre en place une gestion des droits assez fine.


La “hype” Elasticsearch

  • Indipensable à de plus en plus d’entreprises qui grossissent : pour augmenter le contrôle sur les infrastructures.
  • Un outil très versatile et bien fait qui permet de faire de jolis dashboards d’analyse et les gens adorent avoir des jolis dashboards
  • Utile pour faire des big data : c’est un peu le moteur de l’informatique actuelle. Tous les nouveaux services fonctionnent grace au traitement de données.

Dashboards

I) Les évènements d’un système et le logging

I.1) Rappel - pourquoi des Logs ?


Logs ?

  • Ça veut dire journaux (système) et bûches
  • Icone originale de Logstash:

Comprendre ce qui se trame

  • Prendre connaissance et analyser les évènements d’un système d’un point de vue opérationnel.
  • Les évènements en informatique sont invisibles et presque instantanés.
  • Les journaux sont la façon la plus simple de contrôler ce qui se passe
    • Des fichiers textes simple avec une ligne par évènement

Objectif 1: monitoring

  • Suivre et anticiper le fonctionnement d’un système:
    • suivre (et réparer) = zut j’ai une erreur : le service nginx a crashé sur mon infra
    • anticiper : le disque dur de cette machine sera bientôt plein il faut que je le change / le vide.
    • enquêter : par exemple sur les erreurs rares d’une application

Objectif 2 : conserver les traces de ces évènements pour analyse

  • Archiver pour analyser sur la longue durée (6 mois à 1 an ?) avec des graphiques.

  • Exemples : ces derniers mois est-ce que l’application a correctement répondu aux requêtes de mes utilisateurs ?

    • Compter le nombre de timeout (application est trop lente ?)
    • Compter le nombre de requêtes pour savoir quand sont les pics d’usage dans la journée
    • Connaître la provenance des requêtes et le délai de réponse pour savoir
      • si les serveurs sont correctement disposés géographiquement.
      • si les requêtes sont “routées” (redirigées) vers le bon serveur.

Infra distribuée


Exemples de fichier de logs

  • chaque application peut avoir un fichier de log
  • ou alors on peut les rassembler dans un le même fichier
  • les logs sont dans /var/log

Vous en connaissez ?


Exemples de fichier de logs

Exemples de fichiers de logs :

  • auth.log : connexion des utilisateurs au système
  • httpd.log : connexion au serveur web apache
  • mail.log : aussi bien envoi que réception de mails
  • nginx/access.log : connexion au serveur web nginx
  • nginx/error.log : erreurs de connexion au serveur web nginx

Exemple d’investigation

Objectif:

  • analyser des logs pour retrouver une information
  • être attentif-ve au format des logs

Sur le serveur exemple.net, une page web a été supprimée. On veut savoir qui des trois administrateurs Alice, Bob ou Jack a fait cette modification.

  1. On se connecte en SSH
  2. en utilisant cat et grep par exemple :
  • Pour connaître le titre du site au fil du temps consultez le fichier /var/log/nginx/access.log
  • on utilise | grep 403 et | grep 200 pour savoir quand la page a disparu (en cherchant les codes d’erreur HTTP)
  • Pour savoir qui s’est connecté on consulte le fichier /var/log/auth.log
  • on utilise | grep et l’heure pour savoir qui s’est connecté à cette heure ci
`/var/log/nginx/access.log` :
`/var/log/auth.log` :

Bilan

  • Explorer les logs “à la main” c’est pas toujours très pratique.
  • Chercher des évènements datés en filtrant n’est pas très adapté.
  • Résoudre un problème nécessite de les interpréter.
  • Pour cela on doit chercher et croiser des informations diverses avec un but.

I.2) Le problème avec les logs d’une infrastructure


Décentralisé

  • Une infrastructure c’est beaucoup de machines: les logs sont décentralisés à plein d’endroits.

    • Au delà de 3 machines pas question de se logguer sur chacune pour enquêter.
  • On veut un endroit centralisé pour tout ranger.


La quantité

  • Des millions et des millions de ligne de journaux, ce qui représente potentiellement des teraoctets de données.
  • Cette quantité faramineuse de données texte il faut pouvoir:
    • la stocker et la classer, l’uniformiser (les logs ont pleins de format différents)
    • chercher dedans par date efficacement.
    • croiser les données

La stack ELK


La stack ELK

  • Les Beats pour lire les données depuis plusieurs machines. Les principales sont :

    • FileBeat : lire des fichiers de log pour les envoyer à Logstash ou directement à Elasticsearch
    • MetricBeat : récupérer des données d’usage, du CPU, de la mémoire, du nombre de process NGINX
  • Logstash : récupère les logs pour les traiter avant de les envoyer dans Elasticsearch

    • formater des logs
    • transformer les données avant de les mettre dans Elasticsearch
  • Elastic APM

    • Elastic APM permet d’envoyer des mesures d’une application à Elasticsearch, il y a un agent à intégrer qui dépend du langage : l’agent d’une applicatin Java par exemple va faire remonter des statistiques sur la JVM.

Quelques forces d’Elasticsearch et ELK

  • Facile à agrandir: (elastic) c’est une application automatiquement distribuée.
    • Ajout d’un nouveau noeud, réindexation et hop.
  • Presque en temps réel : Les évènements sont disponibles pour la recherche presque instantanément
  • Recherche très rapide : sur des gros volumes

Exercice I.2)

Calculons la quantité de log que produisent 12 instances d’une application pendant un mois Chaque instance = Un serveur web, une application python + une base de données pour toutes les instances

  • Chercher la taille d’une ligne de log ?
  • Combien pèse un caractère ?
  • Comment mesurer la quantité de lignes produites par une application ?
    • on va retenir 200 lignes par minute en moyenne pour le serveur web
    • 120 pour l’application python
    • 60 pour la DB -> c’est très variable
  • Faire le calcul
  • Conclusions…

1 - Installation

TP 1 : installation d’Elasticsearch, Kibana et Filebeat

Installer Elasticsearch avec Ansible

  1. Clonez le dépôt situé à cette adresse : https://github.com/Uptime-Formation/vagrant-ansible-elk
  2. Créez les VM avec vagrant up (il faut installer Vagrant et VirtualBox avant si ce n’est pas fait)
  3. Vagrant a de lui-même lancé ansible-playbook ping.yml, il teste donc qu’Ansible est bien configuré.
  4. Lancez ansible-playbook setup_elastic.yml. Les requirements sont installés ! Voyez les ok et changed apparaissant lorsque vous lancez le playbook : Ansible est verbeux, il informe de sa réussite.

Rappels Ansible :

  • Ansible peut être rejoué plusieurs fois (il est idempotent)
  • Ansible garantit l’état de certains éléments du système lorsqu’on le (re)joue
  • Ansible est (dès qu’on est un peu habitué-e) plus limpide que du bash

Configurer Elastic en cluster

  1. Observez le fichier templates/elasticsearch.yml.j2 : c’est modèle de fichier de configuration. Il contient des trous {{ ma_variable }} qui doivent être remplis par les variables du playbook

  2. Jouer le playbook complet.

  3. Lancez les commandes de diagnostic

  • curl http://192.168.2.2:9200/_cat/nodes?pretty
  • curl -XGET http://192.168.2.2:9200/_cluster/state?pretty
  • curl -XGET http://192.168.2.2:9200/_cluster/health?pretty

Si tout est bien configuré vous devriez voir une liste de deux nœuds signifiant que les deux elastic se « connaissent »

  • Pour ajouter un nouveau nœud !

    • ajoutez une nouvelle machine dans Vagrant
    • l’ajouter au fichier hosts.cfg dans le groupe elastic_nodes
    • ajoutez la nouvelle IP dans la variable elk_node_ips
  • relancer le playbook : #magic

Installer Kibana

  • Lancer : ansible-playbook setup_kibana.yml

  • Accéder à 192.168.2.4:5601 dans Firefox 😃

Installer Elasticsearch avec Docker Compose

L’utilité d’Elasticsearch est que, grâce à une configuration très simple de son module Filebeat, nous allons pouvoir centraliser les logs de tous nos conteneurs Docker. Pour ce faire, il suffit d’abord de télécharger une configuration de Filebeat prévue à cet effet :

curl -L -O https://raw.githubusercontent.com/elastic/beats/7.10/deploy/docker/filebeat.docker.yml

Renommons cette configuration et rectifions qui possède ce fichier pour satisfaire une contrainte de sécurité de Filebeat :

mv filebeat.docker.yml filebeat.yml
sudo chown root filebeat.yml
sudo chmod go-w filebeat.yml

Enfin, créons un fichier docker-compose.yml pour lancer une stack Elasticsearch :

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.5.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    networks:
      - logging-network

  filebeat:
    image: docker.elastic.co/beats/filebeat:7.5.0
    user: root
    depends_on:
      - elasticsearch
    volumes:
      - ./filebeat.yml:/usr/share/filebeat/filebeat.yml:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - logging-network
    environment:
      - -strict.perms=false

  kibana:
    image: docker.elastic.co/kibana/kibana:7.5.0
    depends_on:
      - elasticsearch
    ports:
      - 5601:5601
    networks:
      - logging-network

networks:
  logging-network:
    driver: bridge

Il suffit ensuite de :

  • se rendre sur Kibana (port 5601)
  • de configurer l’index en tapant * dans le champ indiqué, de valider
  • et de sélectionner le champ @timestamp, puis de valider.

L’index nécessaire à Kibana est créé, vous pouvez vous rendre dans la partie Discover à gauche (l’icône boussole 🧭) pour lire vos logs.

Il est temps de faire un petit docker stats pour découvrir l’utilisation du CPU et de la RAM de vos conteneurs !

Facultatif : Ajouter un nœud Elasticsearch

`docker-compose.yml` :

2 - Elasticsearch

Elasticsearch

Elasticsearch est à la fois :

  • une base de données distribuée (plusieurs instances de la base de données sont connectées entre elles de manière à assurer de la redondance si un des nœuds en vient à avoir des problèmes)
  • un moteur de recherche puissant, basé sur un autre logiciel appelé Apache Lucene

Elle fait partie des bases de données de type NoSQL.


Comparaison entre les BDD SQL et NoSQL.

  • SQL : des tableaux qu’on peut croiser = Jointures

ex: MySQL, PostgreSQL, Microsoft Access

  • NoSQL: des documents qu’on peut filtrer et aggréger

ex: MongoDB, CouchDB, Elasticsearch

Le point commun des deux : Stocker des données de base pour une application.

Ex: un Site ou web ou un utilisateur a acheté une liste de produit

  • utilisateur: login, email, mdp, présentation, age, image de profil
  • produit: ref, description, prix, photo
  • facture et garantie: documents complexes mais créés une fois pour toute.

SQL: On veut avoir un historique des achats et les documents afférents : on relie formellement utilisateurs et les produits à travers un historique d’achat.

NoSQL: On stocke les factures comme des documents JSON.

Côté SQL:

ça donne trois tables

  • schéma de données liées en SQL
  • concevoir correctement pour pas être coincé : il faut que les données soient reliées aux bons endroits et efficacement.
  • effectuer une recherche de texte approximative (par exemple) ou un peu complexe (comme Google) n’est pas simple.

Côté NoSQL:

des documents JSON qu’on va récupérer avec une référence

  • le schéma est facultatif et moins important
  • fait pour chercher plutôt que supporter le modèle des données.
  • moins de pression à concevoir correctement pour pas être coincé : il faut que les données répondent quand même à un schéma qu’on va essayer de ne pas trop modifier, mais ce n’est pas un problème si cela se fait dans un second temps.

Avec des BDD SQL et NoSQL

  • SQL : données homogènes, cohérentes et fortement changeantes
  • NoSQL : données complexes mais moins de cohérence

Elasticsearch : une sorte de BDD mais pour la recherche de texte

  • Assez proche de MongoDB : on met des documents JSON dedans en HTTP.
  • On jette des trucs dedans qu’on voudrait analyser plus tard
  • On explore ces éléments en faisant des recherche et des graphiques

A chaque tâche son outil

  • Elasticsearch n’est pas conçu pour soutenir l’application pour toutes ses données, seulement pour la partie recherche / analyse.
  • Dans notre cas Elasticsearch sert pour travailler sur les logs

Dev tools

  • Pour exécuter directement des requêtes REST (on revient sur ce que c’est juste après)
  • Ctrl+Entrée ou “Play” pour lancer la commande selectionnée.

  • C’est cette vue qu’on va principalement utiliser dans les premières parties.

  • Elle montre mieux les dessous de Elasticsearch.

  • Il faut que vous compreniez bien le principe d’une API REST JSON parce que c’est très répandu.

Connaitre la version de Elasticsearch

Dans la vue dev tools tapez:

GET /

réponse:

{
    "name": "ZEWiZLN",
    "cluster_name": "elk_formation",
    "cluster_uuid": "rGzTBgbXRyev62Ku4vTWFw",
    "version": {
        "number": "7.14.1",
        ...
    },
    "tagline": "You Know, for Search"
}

Version de Elasticsearch

  • Version 7.14. C’est important car entre chaque version majeure (3, 4, 5, 6, 7) il y a des changements dans les fonctions (L’API)
  • La référence c’est la documentation: https://www.elastic.co/guide/en/elasticsearch/reference/7.14/index.html
  • Toutes les fonctions de elasticsearch y sont décrites et on peut choisir la version selon celle installée.

Bonus : Principaux changements entre Elasticsearch 7 et 8

Elasticsearch 8 introduit surtout une modification clé :

  1. Suppression des *mapping types Les types de mappage ont été retirés, simplifiant la modélisation des données. Cela permettait de mettre au sein d’un même index plusieurs “types de document”, maintenant on n’utilise plus qu’un seul type de document par index, appelé _doc (les mappings, automatiques et manuels (aussi appelés mappings explicites) existent toujours).

L’organisation basique de Elasticsearch


L’architecture basique de Elasticsearch

  • Index :
    • comme une bibliothèque de documents
    • comme une base de données en SQL
    • on peut en créer plusieurs (bien sûr)

L’architecture basique de Elasticsearch

  • Index avec son Mapping
    • un peu comme une table en SQL
    • mapping = format c’est title+author+price+description

mapping signifie représenter/modéliser en anglais.

  • Documents
    • chaque entrée dans un index avec son id
    • ici un livre ou un vol
    • un peu comme une ligne dans une table en sql

Les opérations de base de l’API = CRUD

  • “ajouter un index/mapping/document” (Create)
  • “récupérer/lire un index/mapping/document” (Read)
  • “mettre à jour un index/mapping/document” (Update)
  • “supprimer un index/mapping/document” (Delete)

Syntaxe d’un appel de fonction

<METHODE> <URI>
<DATA>
PUT /bibliotheque/_doc/1
{
    "title": "La Promesse de l'aube",
    "description": "[...] J'entendis une fois de plus la formule intolérable [...]",
    "author": "Romain Gary"
}

Le BODY

  • est facultatif
  • est en JSON (JavaScript Objet Notation)
    • décrire des données complexes avec du texte
    • très répendu
    • pas trop dur à lire pour un humain

Syntaxe du JSON

{
    "champ1": "valeur1",
    "champ2_nombre": 3, // pas de guillemets
    "champ3_liste": [
        "item1",
        "item2",
        "item3",
    ],
    "champ4_objet": { // on ouvre un "nouveau json" imbriqué
        "souschamp1": "valeur1.1";
        ...
    },
    "champ5": "Pour échapper des \"guillemets\" et des \\n" // échappement pour " et \
}

Exercice II.1) syntaxe API et JSON

CRUD et méthode HTTP

<METHODE> <URI>
<DATA>

METHOD en gros (il y a des exceptions sinon c’est pas drôle) :

  • GET = Read / récupérer
  • POST = Créer
  • PUT = Mettre à jour / Update
  • DELETE = Supprimer

Exercice II.2.1) Gérer les documents dans Elasticsearch.

II.2.2) Gérer les mappings et les index

Mapping implicite et Mapping explicite

Lorsque vous ajoutez un document sans avoir créé de Type de document et de mapping (=format) pour ce type, elasticsearch créé automatiquement un format en devinant le type de chaque champ:

  • pour les champs texte il prend le type text + keyword (on verra pourquoi après)
  • pour champs numériques il prend le type integer ou float

C’est le mapping implicite Mais si on veux des champs spéciaux ou optimisés il faut créer le mapping soi-même explicitement.


Mapping explicite

Pour avoir plus de contrôle sur les types de champs il vaut mieux décrire manuellement le schéma de données. Au moins les premiers champs qu’on connaît déjà.

(Il peut arriver qu’on ait pas au début d’un projet une idée de toutes les parties importantes. On peut raffiner le mapping au fur et à mesure)


Afficher le(s) mapping(s)

GET /<index>/_mapping

Exemple:

GET /kibana_sample_data_flights/_mapping

Les types de données (datatypes)

Un documents dans elasticsearch est une données complexe qui peut être composé de nombreux éléments hétérogènes

Les types les plus importants: text, keyword, integer, float, date, geo_point


Types texte

  • text : Pour stocker du texte de longueur arbitraire. Indexé en recherche fulltext. On y reviendra: ça veut dire que tous les mots du texte sont recherchables.
  • keyword : Du texte généralement court pour décrire une caractéristique du document
    • Exemple: OriginWeather décrit la météo cloudy

Types nombre

  • integer : un nombre entier
  • float : nombre à virgule

Il existe d’autres types de nombres plus courts ou plus longs (donc plus gourmand en espace).


Type date

Comme on stocke souvent des évènements dans elasticsearch il y a presque toujours une ou plusieurs date dans un document. En fait ce n’est pas vraiment une date mais ce qu’on appelle un timestamp qui va jusqu’à la milliseconde.


Type geo_point

Pour stocker un point géographique. C’est une paire de nombres : latitude et longitude. On verra ça un peu dans kibana plus tard. La stack Elk fournit plein d’outil pour stocker des données géolocalisés et les visualiser : C’est un besoin courant. Exemple : savoir d’où viennent les requêtes sur votre application pour connaître vos usagers.


Exercice II.2.2)

II.3) API REST et JSON ?


Revenons sur le format de l’API

C’est quoi ce format d’appel de fonction: METHOD URI DATA ?


HTTP

  • Le protocole le plus connu pour la communication d’applications
  • protocole = requêtes et réponses formalisées entre deux logiciels
  • exemples:
    • navigateur <-> serveur apache
    • kibana <-> elasticsearch
    • application web <-> mongoDB

En requête

En réponse

  • un fichier avec
  • un en tête nommé HEAD qui gère décrit la réponse avec des métadonnées
  • le HEAD contient notamment un code de réponse :
    • 200 = OK
    • 404 = non trouvé
  • un contenu nommé BODY

API REST

  • API = Application Programming Interface : “Une liste de fonctions qu’on peut appeler de l'extérieur d’un logiciel”

  • REST signifie REpresentational State Transfer.

  • C’est un format standard (le plus répendu) pour une API.

  • C’est-à-dire une façon de décrire la liste des fonctions et leurs paramètres.

Curl, l’outil HTTP

  • GET / devient : curl -XGET http://localhost:9200/
PUT /catalog/product/1
{
    "sku": "SP000001",
    "title": "Elasticsearch for Hadoop",
    "description": "Elasticsearch for Hadoop",
    "author": "Vishal Shukla",
    "ISBN": "1785288997",
    "price": 26.99
}

Devient :

$ curl -XPUT http://localhost:9200/catalog/product/1 -d '{ "sku": "SP000001",
"title": "Elasticsearch for Hadoop", "description": "Elasticsearch for
Hadoop", "author": "Vishal Shukla", "ISBN": "1785288997", "price": 26.99}'

Exercice II.3) Utiliser curl

III) Rechercher et analyser dans Elasticsearch

III.1) Index et recherche de texte

Comme dans une bibliothèque

Indexer des documents c’est comme les ranger dans une bibliothèque. Si on range c’est pour retrouver. Mais on veut vouloir trouver de deux types de façon.

  • Recherche exacte: On veut pouvoir trouver les documents rangés dans la catégorie litterature anglaise ou bandes déssinées SF.
  • Recherche en texte intégral ou fulltext : On veut pouvoir trouver les documents qui ont Lanfeust ou éthique dans leur titre.

Recherche exacte

  • Quand je cherche littérature anglaise je ne veux pas trouver les documents de littérature espagnole bien qu’il y ai le mot “littérature” en commun.
  • Je veux que les termes correspondent précisément ou dit autrement je veux que littérature anglaise soit comme une seule étiquette, pas un texte.
  • C’est le fonctionnement d’une recherche classique dans une base de données SQL:
SELECT * FROM bibliothèque WHERE genre = "littérature anglaise";

Recherche exacte 2

On utilise _search, query et term.

GET /<index>/_search
{
    "query": {
        "term": {
            "<field>": "<value>"
        }
    }
}

Recherche fulltext

  • Retrouver non pas l’ensemble des livres d’un genre mais un livre à partir d’une citation.
  • Pour cela on fait un index inversé qui permet une recherche fulltext.
  • Elasticsearch est spécialement fait pour ce type de recherche. Il le fait très efficacement et sur des milliards de lignes de texte.
    • exemple: github utilise elasticsearch pour indexer des milliers de dépôts de code.

On utilise _search, query et match.

GET /<index>/_search
{
    "query": {
        "match": {
            "<field>": "<value>"
        }
    }
}

Différence entre les champs keyword et text

  • Un champ keyword n’est pas indexé en mode fulltext : la méthode match ne fonctionne pas en mode partiel

  • Un champ text est automatiquement indexé en mode fulltext: la méthode match fonctionne

  • un champ textuel créé implicitement est double : le champ principal en text + un sous champ keyword:

    • exemple: title est un champ text, title.keyword est un champ keyword

Exercice III.1)

III) Life inside a cluster

  • shard
  • dimensionner un cluster
  • haute disponibilité
    • endpoint switching
    • fallback automatique

Exercice:

  • configurer et constater qu’on a le bon nombre de noeuds
  • vérifier que quand il y en a un qui tombe ça marche toujours

III.2) Recherche avec requête multiple et filtre


Des requêtes complexes pour l’analyse

Elasticsearch est puissant pour l’analyse car il permet de combiner un grande quantité de critères de recherche différent en même temps et de transformer les données récupérer pour les rendre significatives.

Imaginons qu’on veuille chercher tous les avions qui ont décollé de New York sous la pluie depuis un mois et qui ont un prix moyen supérieur à 800$. Par exemple pour créer une mesure du risque économique que le dérèglement climatique fait peser sur une companie ?

On va devoir écrire une requête complexe.

Plusieurs outils

  • des requêtes composées tous les vols qui vérifie condition A ET condition B ET PAS condition C
  • des filtres de requêtes garder que les vols dont le prix est entre 300 et 1000 €
  • des aggrégations de requêtes (somme, aggrégation géographique) chercher en gros le chiffre d’affaire d’une companie : faire la somme des trafifs de ses vols.

Repasser à Kibana

On pourrait tout faire avec l’API mais ce serait pas très fun et on s’arracherait vite les cheveux.

2 - Elasticsearch - Exercices

II.1) API JSON

0. Accéder à Kibana

  • aller à l’adresse http://192.168.2.4:5601
  • Dev tools

2. Requêtes

POST /mabibli/_doc/
{
    "<fieldname>": "<value>",
    ...
}

Exercice II.1) syntaxe API et JSON

  1. Chercher un livre sur http://lalibrairie.com

  2. écrire un fichier JSON pour décrire le livre avec:

    • le titre (title)
    • l’auteur (author)
    • le prix (price)
    • la première phrase de la description à mettre entre guillemets (description)
    • d’autres infos si vous voulez
  3. Choisissez un nom simple pour votre bibliothèque.

  4. Ajoutez ce livre à votre bibliothèque dans Kibana à l’aide de la documentation de l’API : https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-index_.html

POST /<votre_bibli>/_doc/1
<DATA>

Solution

Solution :

II.2.1

Exercice II.2.1) Gérer les documents dans Elasticsearch.

Dans la vue Devtools et à l’aide de votre feuille de mémo de l’API :

  1. mettre à jour le livre que vous avez ajouté en changeant le prix
  2. ajouter deux nouveaux livre avec la méthode POST
  3. lister tous les livres de l’index
  4. lister les index présents sur le cluster
  5. supprimer le livre numéro 2 (avec son _id)

Solution

Solution :

Exercice II.2.2)

  1. supprimer votre index

  2. Cherchez dans la documentation comment ajouter un mapping

  3. Décrivez en JSON les propriétés suivantes pour ce mapping en choisissant les types: title, description, author, price, ISBN/EAN, weight

  4. Ajoutez le mapping. Indication : il faut un nouvel index d’abord

  1. Recréez vos deux livres avec POST sans renseigner l’ISBN
  2. ajoutez l’ISBN en modifiant ces livres : problème
  3. ajoutez un champ de type long pour régler le problème

Solution

Solution :

Exercice II.2.3)

Exercice II.3) Utiliser curl

  1. connectez vous à l’infra en ssh:
vagrant ssh <nom-du-noeud>

l’adresse de elasticsearch est 0.0.0.0:9200

  1. taper curl --help, cherchez le nom de l’option longue correspondant à -d (un petit grep ?)
  2. ajouter une suite à l’un de vos livres avec curl.
  3. ajoutez une entrée genre de type keyword dans votre mapping et mettez à jour vos livres pour ajouter leur genre
  4. utilisez curl pour télécharger une page de la documentation dans votre dossier personnel.

Solution

Solution :

Exercice III.1)

Avec la vue Devtools:

  1. Cherchez le nombre d’avion ES-Air (champ Carrier) en tout
  1. Faire une recherche des avions où New apparaît dans le champ Dest. Que remarquez vous ?

Solution

Solution :

3 - Kibana

Kibana

Kibana est un outil très complet de visualisation (dashboards) et d’administration des données dans une base de données Elasticsearch. Elle est toujours connectée à un cluster (un ou plusieurs nœuds) Elasticsearch.

II.0) La tête la première dans Kibana

  • Accédez à http://192.168.2.4:5601/

Vue Discover

Un exemple de données : des vols d’avions

  • Des évènements très similaires à des logs mais plus facile à imaginer :
    • une date
    • un lieu
    • des informations spécifiques
  • Avec des données de géolocalisation (ce qui est pas forcément le cas pour des logs)

Les différents champs décrivant chaque vol

  • DestCityName et OriginCityName - Ville de départ et d’arrivé
  • timestamp - Heure de départ
  • AvgTicketPrice - le prix moyen des places pour le vol
  • FlightTimeHour - Durée en Heure
  • DestWeather, OriginWeather - La météo au départ et à l’arrivée.

Une première recherche

  • Faites une petite recherche : “New York”

Résultat:

  • Resultats exacts : New York
  • Résultats partiels: New Chitose Airport, Louis Armstrong New Orleans International Airport

Régler la Période

  • Combien de vols ?
    • depuis 24h ?
    • depuis une semaine ?
    • depuis 30 jours ?

Dashboard

  • C’est joli mais un peu complexe/flippant, n’est-ce pas ?

IV.1) Rappels recherche

  • Recherche fulltext
  • Exemple: Destfull:“New” -> champ text -> OK New chitose airport Dest:“New” -> champ keyword -> 0 hits
  • Recherche exacte: DestCityName: “New York” -> keyword pour la ville Dest:" John F Kennedy International Airport" -> keyword pour l’aéroport de destination

IV.2) Recherche Complexe avec filtre et aggregations

Des requêtes complexes pour l’analyse

Elasticsearch est puissant pour l’analyse car il permet. - de combiner un grande quantité de critères de recherche différent en même temps - de transformer et afficher les données récupérées pour les rendre significatives


Exemple

Ajouter un filtre avec le bouton “+ Add a Filter”

Imaginons qu’on veuille chercher tous les avions qui ont décollé de New York sous la pluie depuis un mois et qui ont un prix moyen supérieur à 800$. Par exemple pour créer une mesure du risque économique que le dérèglement climatique fait peser sur une companie ?

On va devoir écrire une requête complexe.


requêtes composées

  • Des requête avec des ET des OU et des NON :

  • Tous les vols qui concernent tel aéroport et qui contiennent le nom airways.

Filtres de requêtes

  • En partant des résultats d’une recherche fulltext :

  • On récupère les documents renvoyés par une requête (ce qu’elastic appel des hits) et on ne va en garder qu’une partie.

  • Garder que les vols dont le prix est entre 300 et 1000 €:

    • FlightDelayMin:[30 TO 50]
    • rajouter un filtre avec le bouton “+ Add a Filter”
  • La période de temps en haut à droite de kibana est aussi un filtre


Aggrégations des résultats de requêtes

  • Très proche d’un group by en SQL.

  • Grouper les documents/évènements par thème et faire des calculs transformations sur ces groupes.

  • Pour calculer le prix moyen d’un ticket par compagnie par exemple : On va aggréger les vols de chaque compagnie et calculer la moyenne des prix des billets.


3 type d’aggrégations:

  • Bucket (faire des groupes)

    • Grouper les vols par prix.
  • Metric (travailler sur une dimension des données)

    • calculer la moyenne des prix, ou du retard des vols
  • Geographique (grouper par zone géographique)

    • On peut combiner les aggrégations

Une métrique des données

  • Métrique = caractéristique chiffrée des données.
    • # dans liste des propriétés dans Kibana. (pour faire une moyenne il faut une quantité)

Créer des visualisations

  • Une fois qu’on sait croiser des critères de recherche on peut créer des visualisations.

  • Permet de voir une proportion ou un changement en un coup d’oeil (quand on sait de quoi ça parle).


Intérêts de la Dashboard

  • Vue globale pour comprendre rapidement les données

  • Tout est dynamique: vous pouvez ajouter un filtre et les informations se mettent à jour.

3 - Kibana - Exercices

Exercices

Rappel : Kibana est une interface pour Elastic (soit on attaque direct Elastic soit on utilise les trucs pratiques de Kibana)

  • utiliser les données d’aviation
  • explorons l’interface
  • explorons les graphiques

Recherche dans Kibana

  • Tous les avions en provenance de New York qui ont eu du retard ?
Solution :
  • La quantité d’avions ayant eu du retard hier soir entre 21h30 et 22h ?
Solution :
  • Le prix moyen des billets par compagnie avec une visualisation

    Solution :

  • Aller dans la section dashboard. Explorer les différentes visualisations pour comprendre de quoi elles parlent

    • Utilisez la section contrôle pour ajouter des filtres

Exercices supplémentaires

  • requête pour analyser une erreur dans le code
  • graphique sur le volume de connexion au cours de la journée
  • (difficile) trouver les correspondances possibles pour aller d’une ville A à une ville B entre telle et telle heure ?

4 - Beats

Beats

Beats est un programme designé pour être extrêmement léger et n’avoir qu’une seule mission : récupérer et envoyer des logs à un autre programme qui s’assurera du traitement de ceux-ci : soit Logstash, soit directement Elasticsearch.

  • Les Beats pour lire les données depuis plusieurs machines. Les principales sont :

    • FileBeat : lire des fichiers de log pour les envoyer à Logstash ou directement à Elasticsearch
    • MetricBeat : récupérer des données d’usage système, du CPU, de la mémoire, etc.
    • Packetbeat : récupérer des données très poussées sur le réseau
    • d’autres existent mais sont moins importants

Logstash

Logstash est un couteau suisse puissant de récupération, de transformation et d’envoi de logs. Contrairement à Kibana et Elasticsearch, Logstash peut être utilisé de façon indépendante à Elasticsearch ou à Kibana.

Il est un peu difficile de comprendre la différence fondamentale entre Beats et Logstash au début, on peut retenir :

  • que Beats a beaucoup moins de fonctionnalités que Logstash, et qu’il n’a que quelques missions simples à remplir,
  • là où Logstash est un outil très complet pour récupérer, transformer et renvoyer des logs.
  • dès que l’on est restreint-e par les possibilités de Beats, on utilise souvent à la fois Beats et Logstash

4 - Beats - Exercices

Filebeat avec Nginx

Nous allons suivre la partie Filebeat (il faut descendre jusqu’à environ la moitié de la page) du tutoriel officiel Elastic pour monitorer les logs access.log et error.log de Nginx : https://www.elastic.co/fr/blog/how-to-monitor-nginx-web-servers-with-the-elastic-stack

Nous pouvons ensuite utiliser une commande spéciale pour ajouter des tableaux pré-configurés pour Nginx et Kibana avec la commande suivante : sudo ./filebeat setup --dashboards

Optionnel : Metricbeat pour Nginx

Suivre la partie Metricbeat pour Nginx (sans Docker) du tutoriel : https://www.elastic.co/fr/blog/how-to-monitor-nginx-web-servers-with-the-elastic-stack

Optionnel : Filebeat et Metricbeat pour des conteneurs Docker

Suivre les parties reastantes Configurations Autodiscover de Filebeat et Metricbeat du tutoriel : https://www.elastic.co/fr/blog/how-to-monitor-nginx-web-servers-with-the-elastic-stack

Optionnel : auth.log et syslog

Avec Filebeat, envoyez le contenu des fichiers auth.log (logs de connexion des utilisateurs au système) grâce à la configuration d’un inputs de type log dans Filebeat en indiquant le chemin du fichier (cf. documentation). Regardons dans Kibana : les données arrivent, mais ne sont pas structurées.

Puis, envoyez le contenu des fichiers auth.log et syslog (logs système) à Elasticsearch grâce au module appelé system : https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-module-system.html

Optionnel : journald avec Journalbeat

Avec Journalbeat, envoyez le contenu des fichiers de type journal de systemd : : https://www.elastic.co/guide/en/beats/journalbeat/master/journalbeat-installation-configuration.html

Optionnel : Metricbeat dans et pour Kubernetes

Avec un Kubernetes joignable (par exemple k3s), suivre ce guide : https://www.elastic.co/guide/en/beats/metricbeat/current/running-on-kubernetes.html

Optionnel : Metricbeat pour Docker

Suivre ce tutoriel sur un host avec Docker d’installé : https://www.elastic.co/guide/en/beats/metricbeat/current/metricbeat-module-docker.html

5 - Logstash

Logstash

Logstash est un couteau suisse puissant de récupération, de transformation et d’envoi de logs. Contrairement à Kibana et Elasticsearch, Logstash peut être utilisé de façon indépendante à Elasticsearch ou à Kibana.

  • Logstash : récupère les logs pour les traiter avant de les envoyer dans Elasticsearch
    • formater des logs
    • transformer les données avant de les mettre dans Elasticsearch

Logstash a trois grandes parties :

  • les inputs, là où Logstash récupère ou reçoit ses données, (en général, c’est Beats)
  • les filters, la partie importante, celle où les données reçues sont transformées avant envoi
  • les outputs, là où on indique à Logstash où envoyer ses données (en général : vers Elasticsearch)

Exemples

Inputs

  • des tweets issus de l’API Twitter
  • des packets HTTP

Filters

  • Dissect (basique, en fonction d’un séparateur) et Grok (avancé, expressions régulières) : découper des messages de logs non structurés en plusieurs entrées différentes (par exemple découper chaque info d’une ligne de logs de Nginx dans des entrées différentes)

  • Geoip : ajouter des infos géographiques à partir d’une adresse IP

Outputs

  • Elasticsearch
  • l’exécution d’une ligne de commande (par exemple iptables pour couper l’accès firewall à une IP après avoir détecté une attaque)

Rappel : Beats et Logstash

Il est un peu difficile de comprendre la différence fondamentale entre Beats et Logstash au début, on peut retenir :

  • que Beats a beaucoup moins de fonctionnalités que Logstash et est designé pour être très léger, et n’avoir que quelques missions simples à remplir
  • là où Logstash est un outil très complet pour récupérer, transformer et renvoyer des logs.

Pour plus de détails : https://www.elastic.co/guide/en/beats/filebeat/current/diff-logstash-beats.html

Beats avec Logstash

Souvent, parce que leurs missions sont complémentaires, on associe des Beats qui envoient leurs logs bruts à Logstash, qui s’assure du traitement et de la transformation des logs

-->

5 - Logstash - Exercices bonus

Dissect ou Grok avec Nginx

Sur votre ordinateur ou dans une VM créé par Vagrant, faire du Logstash en utilisant le filtre Dissect ou Grok et des logs Nginx récupérés par Filebeat en suivant ce tutoriel : https://blog.zwindler.fr/2017/10/10/elasticstack-collecter-et-exploiter-des-logs-nginx/

L’input Twitter

Avec une clé d’API Twitter (à demander éventuellement au formateur), configurer l’input Twitter de Logstash pour archiver des tweets dans Elasticsearch. https://www.elastic.co/guide/en/logstash/current/plugins-inputs-twitter.html

https://grokdebug.herokuapp.com/

https://www.elastic.co/guide/en/logstash/7.14/plugins-filters-dissect.html

6 - Conclusion


Qu’est-ce qu’un cluster ?

  • Un ensemble de machines qu’on appelle des noeuds (nodes) reliés par un réseau fiable et rapide.

Haute disponibilité

Une application en haute disponibilité signifie qu’elle continue à fonctionner quand une partie arrête de fonctionner (dans le cadre d’Elasticsearch : quand un nœud devient injoignable par exemple).

Les mécanismes de haute disponibilité d’un cluster commencent réellement à partir de 3 nœuds : il faut 2 nœuds restants pour continuer à fonctionner sans le 3e nœud défectueux.

Santé d’un cluster / d’un indice

La santé d’un cluster ou d’un index est déterminée par trois couleurs dans Elasticsearch :

  • vert, tout va bien, la haute disponibilité fonctionne
  • jaune, il n’y a pas de redondance : si un nœud devient injoignable ou par exemple son disque casse, il y a un risque de perdre des données ou de perdre un accès à des données
  • rouge, des données sont introuvables/perdues

Elasticsearch est élastique/distribué

  • Une application distribuée a plusieurs instances (identiques ou non) qui communiquent entre elles.
  • Par exemple des noeuds Elastc contiennent chacun une partie des données :
    • On peut ajouter des noeuds et un index va automatiquement répartir les données entre les nœuds : dans Elasticsearch, on appelle ça le sharding (partition en français), les données sont copiées en plusieurs replicas.

Le scripting dans Elasticsearch

Elastic Common Schema (ECS)

  • Quand on veut optimiser le fait de donner des infos à Elasticsearch avec notre application, on exporte nos logs en JSON. ECS est simplement une façon de standardiser certains champs JSON utiles à fournir à Elasticsearch.

6 - Elastic APM dans Flask - Exercice bonus

Après avoir installé APM server dans votre VM Elasticsearch (par exemple en éditant le script Ansible), intégrez Elastic APM pour Flask en suivant ce tutoriel : https://www.elastic.co/guide/en/apm/get-started/current/install-and-run.html

7 - Bibliographie

API Elasticsearch memento - Version 7.14 de l'API

Gérer les documents

Source : https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-index_.html

Créer un document

PUT /<index>/_doc/1
{
  "champ1": "value1",
  "champ2": "value2"
}

ou

POST /<index>/_doc
{
  "champ1": "value1",
  "champ2": "value2"
}

Afficher un document:

GET /<index>/_doc/<num>/

Lister tous les documents:

GET /<index>/_search

Mettre à jour un document (ajouter/modifier un champ)

POST /<index>/_update/<num>/
{
    "doc": {
        "field": "value"
    }
}

Supprimer un document

DELETE /<index>/_doc/<_id>

Gérer les index

List Indices

GET /_cat/indices
  • avec le nom des colonnes
GET /_cat/indices?v

Create index

PUT /<index>
{
    "settings": {
        "number_of_shards": 1, // default 5
        "number_of_replicas": 0 // default 1
    }
}

Avec un mapping directement

PUT /<index>
{
  "settings": {
    "index": {
      "number_of_shards": 1,
      "number_of_replicas": 0
    }
  },
  "mappings": {
      "properties": {
        "<property>": {
          "type": "<datatype>"
        }
      }
    }
  }
}

Supprimer un index

DELETE /<index>

Gérer les mappings

Lister les mappings

GET /<index>/_mapping

Ajouter un champ à un mapping:

PUT /<index>/_mapping
{
  "properties": {
    "<new_fieldname>": {
      "type": "<datatype>"
    }
  }
}

Réindexer des données

Dupliquer un champ et réindexer

POST /<index>/_update_by_query
{
  "script": {
    "inline": "ctx._source.<fieldname> = ctx._source.<fieldname>"
  }
}

Fil rouge DevOps

Introduction

L’objectif de ce TP est de faire la démonstration pratique de la plupart des éléments techniques appris durant le cursus DevOps.

L’activité de DevOps dans une équipe est une activité de support au développement et d’automatisation des divers éléments pratiques nécessaire au bon fonctionnement d’une application. Elle est par nature intégrative.

Ce TP consiste donc logiquement à rassembler les aspects pratiques (éléments vus en TP) découverts dans les modules du cursus et de les combiner autour d’une infrastrure Kubernetes pour réaliser en particulier une CI/CD de notre application utilisant Jenkins.

Attention :

  • Toutes les parties ne sont pas forcément obligatoire. L’appréciation sera globale. Les bonus sont des idées de personnalisation à réaliser si vous avez le temps et le courage.

  • Ce sujet de TP est loin d’être simple :

    • N’hésitez pas à demander de l’aide aux formateurs.
    • Collaborez et partagez la compréhension des enjeux dans le groupe.
  • Le sujet est succeptible d’évoluer au fur et à mesure en fonction de vos retours et demandes d’information.

  • Les parties de la fin du cursus (Jenkins et peut-être le Monitoring et/ou AWS et/ou Ansible) seront ajoutées par la suite.

  • N’oubliez pas de vous reposer pendant les vacances !!

Rendu

Le rendu du TP est à effectuer par groupe.

Pour chaque groupe les éléments suivant devront être présentés lors de la présentation finale du cursus:

  • Une présentation décrivant les différents élements de l’infrastructure et leurs objectifs ainsi que les choix réalisés lors de la réalisation.

  • On peut se servir de diapositives afin d’avoir un support oral. L’idée est de voir la gestion du temps, l’expression orale et évidemment le côté technique. Et attention, à la répartition de parole dans le groupe, chacun doit occuper sa place.

  • La qualité des diapositives est notée également.

  • La présentation dure 20mn, 10mn de plus de questions du jury, 5 mn de délibération du jury sans les stagiaires et 5 mn de compte rendu au groupe de la part du jury.

  • Pas de rapport écrit à part les diapositives.

Objectifs

  • Mettre en œuvre un système d’intégration continue et de déploiement DevOps

  • Construire une image capable de servir à l’application

  • Automatiser la construction d’images

  • Mettre à jour et déployer automatiquement des images

  • Une installation fonctionnelle de l’infrastructure et de l’application du TP installé sur cette infrastructure telle que décrite dans l’énoncé suivant.

  • Deux dépots de code sur Github ou Gitlab contenant pour le premier le code d’infrastructure et pour le second l’application à déployer sur l’infrastructure.

0 - Vagrant et Virtualbox: créer une machine virtuelle avec du code

Une infrastructure est généralement composée de machines virtuelles pour la flexibilité, qu’elles soient louées chez un provider de cloud comme Amazon Web Service ou créées à l’aide d’un hyperviseur comme Virtualbox (ou VMWare ou Proxmox etc).

Dans ce TP nous allons utiliser Virtualbox pour créer un ou plusieurs serveurs (selon vos préférences, voir bonus kubernetes installation dans la suite). Pour respecter les bonnes pratiques de l’infrastructure as code et pouvoir partager et reproduire l’installation nous aimerions créer ces machines virtuelles à l’aide de code descriptif. L’outil adapté pour cela s’appelle Vagrant.

curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install vagrant
  • Créez un dossier pour votre code d’infrastructure par exemple tp_fil_rouge_infra et ajoutez à l’intérieur un fichier Vagrantfile contenant le code suivant:
Vagrant.configure("2") do |config|
    config.vm.provider :virtualbox do |v|
      v.memory = 2048
      v.cpus = 2
    end

    config.vm.define :master do |master|
      # Vagrant va récupérer une machine de base ubuntu 20.04 (focal) depuis cette plateforme https://app.vagrantup.com/boxes/search
      master.vm.box = "ubuntu/focal64"
      master.vm.hostname = "master"
      master.vm.network :private_network, ip: "10.10.0.1"
    end
  end
  • Entrainez vous à allumer, éteindre, détruire la machine et vous y connecter en ssh en suivant ce tutoriel: https://les-enovateurs.com/vagrant-creation-machines-virtuelles/. (pensez également à utiliser vagrant --help ou vagrant <commande> --help pour découvrir les possibilités de la ligne de commande vagrant).

Remarques pratiques sur Vagrant :

  • Toutes les machines vagrant ont automatiquement un utilisateur vagrant.
  • Vagrant partage automatiquement le dossier dans lequel est le Vagrantfile à l’intérieur de la VM dans le dossier /vagrant. Les scripts et autres fichiers sont donc directement accessibles dans la VM.

1 - Application Web Python et Linux

En vous aidant du tutorial suivant (jusqu’à la partie 5, avant la partie certbot): https://www.digitalocean.com/community/tutorials/how-to-serve-flask-applications-with-gunicorn-and-nginx-on-ubuntu-20-04-fr

  • Installez dans la machine virtuelle Vagrant précédente une application web flask (par exemple celle proposée dans le tutoriel).

  • Rassemblez les étapes d’installation dans un script shell (à ajouter dans le dossier d’infra).

  • Vérifiez que votre script d’installation fonctionne en détruisant et recréant la machine virtuelle (vagrant destroy) puis en lançant le script en ssh.

  • (facultatif) Vous pouvez même ajouter le script directement au Vagrantfile, après la ligne master.vm.network :private_network, ip: "10.10.0.1" avec la syntaxe suivante (cf. la documentation):

      master.vm.provision :shell, privileged: false, inline: <<-SHELL
      commande1
      commande2
      etc
  SHELL

Idée de bonus

2 - Git

Versionner le code de l’application précédente avec Git. Créer un dépôt sur Github ou Gitlab.

  • Un-e membre du groupe crée le dépôt et ajoute ses collègues à l’application en leur donnant le status de maintainer.
  • Poussez le code avec une branche develop, une branche main (production).
  • Chaque membre du groupe créé une branche à son nom et s’efforce de ne plus pousser sur develop ou main dans le futur mais en utilisant sa branche.
  • Le code sera ensuite mergé dans la branche develop et/ou main.

Répétez les étapes précédentes en créant un dépôt pour le code d’infrastructure.

Ces deux dépôts serviront pour la présentation finale de votre code.

Idées de bonus

  • Écrire à l’avance des issues (au fur et a mesure plutôt que toutes au départ) pour décrire les prochaines étapes à réaliser.

  • Utilisez pour la suite du TP des branches pour les issues.

    • Les merger dans main sans passer par develop (les feature branches remplacent la branche develop) en effectuant des pull request Github ou merge requests Gitlab.
  • Utilisez le wiki Github ou Gitlab du dépôt d’infrastructure pour documenter votre infrastructure et servir de support à la présentation finale.

3 - Docker

En s’aidant du TP2 et TP4 du module Docker, et de votre script d’installation existant :

  • Dockeriser une application flask simple (par exemple celle de la partie précédent ou celle du TP Docker à la place) en écrivant un Dockerfile.
  • (facultatif) Ajoutez un fichier docker-compose.yml. pour lancer l’application.
  • Ajoutez les fichiers créées à votre dépôt d’application.

Idée de bonus

4 - Kubernetes installation

En suivant/vous inspirant des TP kubernetes et de la partie 0.

  • En repartant du Vagrantfile de la partie 0 : utilisez la commande master.vm.provision comme indiqué dans la partie 0 ci-dessus pour installer k3s avec la commande curl -sfL https://get.k3s.io | sh -.

  • (facultatif) Trouvez comment supprimer l’ingress Traefik de k3s et installez à la place un ingress nginx plus classique (pour pouvoir exposer l’application web à l’extérieur).

  • (facultatif) Installez cert-manager comme dans le TP avec un générateur de certificat auto-signé : https://cert-manager.io/docs/configuration/selfsigned/

  • Versionnez le Vagrantfile et les fichiers d’installation Kubernetes dans le dépôt d’infrastructure.

Idées de bonus

  • Installez un repository d’image docker simple en vous aidant de tutoriels sur Internet et de l’image registry:2, ou bien de solutions plus avancées
  • Créez un cluster de 3 noeuds k3s avec Vagrant et k3sup.

5 - Kubernetes déploiement de l’application

  • Déployez une application flask dans le cluster en vous inspirant du TP déployer une application de A à Z.
  • Versionnez les fichiers d’installation dans un dossier k8s du dépôt d’application.

Idée de bonus

  • Déployer en plus l’application flask avec une base de donnée externe (voir chapitre 19 du mega tutorial). Installez MySQL à l’aide d’un chart Helm.

Contenu intégral

Exporter les supports en pdf

Pour exporter correctement les TPs et autres pages de ce site au format pdf, utilisez la fonction imprimer de Google Chrome ou Firefox (vous pouvez aussi activer le Mode Lecture de Firefox en cliquant Affichage > Passer en Mode Lecture) en ouvrant la page suivante : Contenu intégral.