Latest / L'humain hackeur du digital / Faut-il vraiment passer au DevOps

Transcript

Faut-il vraiment passer au DevOps · L'humain hackeur du digital

• 0:00
  Le stockage objet,
• 0:02
  c'est le type de stockage.
• 0:04
  Et S3,
• 0:05
  c'est une implémentation de ce type de stockage.
• 0:07
  La génération de ces fichiers-là aussi,
• 0:09
  des fois il y a des gens encore qui remplissent des Excel à la main,
• 0:11
  alors qu'on pourrait automatiser le remplissage de ces fichiers-là.
• 0:15
  Et il y a beaucoup plus d'entreprises qu'on ne le pense qui sont dans le cas où il n'y a pas encore de test et il n'y a même pas un prémice de philosophie DevOps qui est insupplé chez les développeurs.
• 0:32
  Bonjour et bienvenue dans un nouvel épisode l'humain à coeur du digital aujourd'hui on va parler DevOps c'est un sujet qu'on entend de plus en plus dans les médias dans les tendances technologiques IT cloud
• 0:47
  cyber,
• 0:47
  mais qu'est-ce qui se cache derrière ce terme-là ?
• 0:51
  Et donc,
• 0:51
  pour aller plus loin dans la conversation et les échanges,
• 0:55
  je vous demande d'accueillir Louis.
• 0:57
  Salut Louis !
• 0:57
  Salut Julie !
• 0:58
  Ouais,
• 0:59
  on imagine que les gens,
• 1:00
  ils vont applaudir derrière.
• 1:02
  leur écran,
• 1:03
  leur smartphone,
• 1:04
  quand ils vont nous voir.
• 1:05
  Ouh,
• 1:05
  la star,
• 1:06
  Louis !
• 1:07
  Et donc,
• 1:08
  Louis,
• 1:08
  moi,
• 1:08
  j'ai plein,
• 1:09
  plein de questions sur la partie
• 1:11
  DevOps. Donc,
• 1:12
  la première,
• 1:13
  assez simple,
• 1:14
  quand on parle DevOps,
• 1:16
  de quoi on parle ?
• 1:17
  Alors,
• 1:18
  ce qu'il faut savoir,
• 1:18
  c'est que le DevOps,
• 1:19
  c'est aujourd'hui une culture,
• 1:21
  c'est une philosophie.
• 1:22
  Ce n'est pas forcément un métier.
• 1:24
  Et ça,
• 1:25
  dans l'imaginaire collectif,
• 1:26
  c'est un peu dur à appréhender.
• 1:27
  En fait,
• 1:28
  à la base du métier,
• 1:29
  ce sont des administrateurs système réseau.
• 1:32
  en fait,
• 1:32
  je dirais classique,
• 1:33
  auquel on a insufflé la philosophie de DevOps.
• 1:36
  C'est ça la grosse différence.
• 1:38
  C'est très associé à la méthode E-Till Agile.
• 1:40
  La philosophie de DevOps,
• 1:41
  elle s'inscrit dans ce schéma-là,
• 1:42
  finalement.
• 1:43
  Ok.
• 1:43
  Voilà.
• 1:44
  Alors,
• 1:44
  c'est quoi ?
• 1:45
  Alors,
• 1:46
  c'est toute une série de méthodes de travail,
• 1:50
  d'outils qu'on met à disposition,
• 1:51
  qu'on crée pour des équipes,
• 1:53
  principalement des équipes de développement,
• 1:55
  pour les aider à livrer,
• 1:57
  on appelle ça livrer,
• 1:58
  des releases d'applications plus vite,
• 2:00
  de manière autonome.
• 2:01
  automatisé,
• 2:02
  sécurisé et surtout scalable et répétable.
• 2:06
  C'est ça les grands mots du DevOps.
• 2:08
  Mais c'est,
• 2:09
  ok tu dis que c'est une philosophie,
• 2:10
  mais c'est une philosophie qui se situe entre quoi et quoi ?
• 2:14
  Principalement entre les personnes qui vont s'occuper de l'infrastructure sur laquelle va vivre les applications des développeurs et forcément du coup les équipes de développement.
• 2:24
  Ok,
• 2:24
  donc les développeurs logiciels,
• 2:26
  web,
• 2:27
  app.
• 2:27
  Absolument,
• 2:27
  c'est ça.
• 2:28
  Tu l'as un peu dit,
• 2:29
  mais qu'est-ce que ça change ?
• 2:32
  de ce qu'on faisait il y a
• 2:34
  10 ans,
• 2:35
  même 5 ans on va dire,
• 2:36
  et même ce qui se fait encore des fois dans certains milieux.
• 2:40
  Qu'est-ce que ça change réellement ?
• 2:42
  Alors il faut prendre un peu de recul dans l'histoire du développement et se dire qu'il y a une époque,
• 2:49
  révolue ou pas,
• 2:50
  en fonction des équipes,
• 2:51
  des clients,
• 2:52
  ça dépend beaucoup,
• 2:53
  dans lesquelles les développeurs avaient la mainmise totale sur le déploiement de leur application.
• 2:59
  Il n'y avait pas forcément de tests qui était fait sur le code
• 3:01
  il n'y avait pas forcément de suivi qui était fait sur les modifications apportées au code,
• 3:06
  c'est à dire qu'un développeur avait une idée pour ajouter une fonctionnalité,
• 3:09
  il allait dans le code direct en production sur la machine,
• 3:12
  il écrivait sa modif et bim c'était parti.
• 3:14
  Il n'y a pas de test,
• 3:15
  il n'y a pas de test de ce qu'on appelle les tests de non régression,
• 3:17
  c'est à dire que quand un développeur pense développer une nouvelle fonctionnalité,
• 3:21
  il y a moyen qu'il en casse une autre,
• 3:22
  donc c'est une régression.
• 3:24
  Et il n'y avait pas forcément tous les aspects de cyber sécurité auquel on est confronté aujourd'hui,
• 3:29
  il n'y avait en gros pas de contrôle.
• 3:31
  résumé à pas de contrôle on laissait les clés de l'infrastructure aux équipes de développement dont ce n'était pas le métier leur métier c'est de développer donc il a fallu trouver le bon équilibre entre laisser de l'autonomie aux développeurs sans leur laisser les clés entières de l'infrastructure on
• 3:48
  peut dire que avant c'était le développeur qui donnait le périmètre les conditions et tout ça pour que l'ingé de l'infra fasse
• 4:01
  La virtualisation,
• 4:02
  le serveur et tout ça.
• 4:02
  Oui,
• 4:02
  c'est un peu l'idée.
• 4:03
  C'était dans un schéma sans DevOps,
• 4:06
  sans tout ça,
• 4:07
  on créait un espace pour le développeur pour qu'il puisse poser son application et il était autonome.
• 4:14
  Et l'administrateur système qui soutenait...
• 4:15
  s'occupaient de l'infrastructure et ne regardaient pas du tout ce qui se passait dessus.
• 4:18
  Vraiment,
• 4:19
  c'était,
• 4:20
  tu es responsable de ton application,
• 4:21
  de sa sécurité,
• 4:22
  c'est toi qui te débrouilles,
• 4:24
  il n'y avait pas tout ça.
• 4:25
  Et forcément,
• 4:27
  avec les temps qui courent et les changes...
• 4:30
  au niveau des infrastructures,
• 4:32
  on demandait de plus en plus aux développeurs d'être administrateurs système.
• 4:37
  Donc du coup ça leur prend aussi une part de leur temps de travail parce qu'il faut qu'ils s'occupent de tous ces aspects là,
• 4:41
  ils passent moins de temps à développer donc forcément ça paie un peu moins à la direction.
• 4:45
  Donc il fallait trouver justement un nouveau métier,
• 4:48
  une nouvelle méthode de travail qui les rendait plus performants tout en activant toutes les étapes dont on vient de parler.
• 4:55
  Et là vous êtes apparus.
• 4:56
  Et là on est apparus.
• 4:57
  Génial.
• 4:58
  Justement,
• 4:58
  tu parlais d'étapes.
• 4:59
  Est-ce que tu peux tous nous les définir ?
• 5:02
  C'est quoi travailler en mode DevOps ?
• 5:07
  Est-ce qu'on peut dire
• 5:08
  DevOps by design ?
• 5:09
  Comme on dit cybersécurité by design,
• 5:11
  c'est-à-dire au début du projet,
• 5:12
  on prend en compte la cybersécurité.
• 5:14
  Est-ce que là,
• 5:15
  c'est la même chose ?
• 5:15
  C'est un peu la même chose.
• 5:17
  Ça ne se dit pas trop DevOps by design.
• 5:18
  En tout cas,
• 5:19
  moi,
• 5:19
  je ne l'ai pas beaucoup entendu.
• 5:21
  Mais en fait,
• 5:22
  dans ce qu'on applique vraiment en pratique,
• 5:23
  c'est ça.
• 5:24
  C'est du DevOps by Design.
• 5:27
  piliers,
• 5:27
  des étapes qu'on a alors quand je dis on,
• 5:30
  c'est pas nous,
• 5:30
  c'est la communauté on va dire des étapes qui ont été définies pour expliquer par quelles portes on doit passer pour être compliant au niveau DevOps.
• 5:40
  Il y a une phase de planification forcément qu'est-ce qu'on va faire sur l'application en cours,
• 5:46
  qu'est-ce qu'on a prévu de changer il y a forcément la phase de code qui va être la prise par le développeur et à part ces deux phases qui sont prises à 99%
• 5:55
  par les développeurs tout le reste
• 5:57
  c'est aux équipes qui font le DevOps de s'en occuper.
• 6:00
  Et là,
• 6:00
  on parle de test sur le code.
• 6:03
  Vérifier,
• 6:03
  alors c'est des tests qui sont très répétitifs.
• 6:05
  S'assurer qu'une fonctionnalité basique de l'application,
• 6:10
  peu importe les itérations qu'on fait dans le code,
• 6:12
  elle est toujours valable.
• 6:13
  Les fameux tests de non-régression,
• 6:14
  on vérifie que tout va bien et qu'on n'a rien cassé.
• 6:17
  On rajoute,
• 6:18
  ça c'est une nouveauté.
• 6:19
  Alors,
• 6:19
  nouveauté dans le monde de l'informatique,
• 6:21
  c'est très relatif.
• 6:22
  On va dire que ça a apparu il n'y a pas très longtemps,
• 6:24
  c'est qu'on se met en focus sur ce qu'on appelle les tests.
• 6:26
  test end-to-end.
• 6:27
  Je ne sais pas si tu sais ce que c'est.
• 6:29
  Pas du tout,
• 6:29
  mais j'ai hâte de savoir.
• 6:30
  C'est une étape qu'on a volée aux équipes d'assurance qualité,
• 6:36
  qui permet de s'assurer qu'un parcours utilisateur sur l'application se déroule bien de A à Z.
• 6:43
  Par exemple,
• 6:43
  on va simuler,
• 6:44
  si on parle d'une application web,
• 6:45
  on va simuler un utilisateur qui va se connecter sur un portail,
• 6:49
  qui va naviguer dans des dossiers,
• 6:51
  qui va cliquer sur des liens,
• 6:53
  et on attend un retour de ce test-là.
• 6:55
  Alors,
• 6:55
  tout se passe en ligne du coup.
• 6:56
  de commandes de manière automatisée.
• 6:58
  Et à la fin,
• 6:59
  on a juste un résultat qui nous dit OK,
• 7:00
  test,
• 7:01
  je ne sais pas,
• 7:01
  120 sur 120 passe.
• 7:02
  Et on passe à l'étape d'après.
• 7:04
  L'étape d'après,
• 7:05
  c'est là où on commence la partie infrastructure.
• 7:09
  On va packager l'application dans ce qu'on appelle un conteneur,
• 7:12
  dont on va parler après.
• 7:14
  Et ce conteneur-là,
• 7:15
  on va aussi lui faire subir des choses.
• 7:17
  On va aller le poser à un endroit pour qu'il soit stocké,
• 7:19
  versionné,
• 7:20
  forcément.
• 7:21
  On aura différentes versions de l'application,
• 7:22
  donc on les garde toutes avec une rétention qu'on définit à l'avance.
• 7:26
  Et super.
• 7:26
  Ce package containerisé,
• 7:28
  c'est là qu'on va aller s'amuser à le déployer.
• 7:30
  Et quand on parle de déploiement,
• 7:32
  là,
• 7:32
  on force ce qui n'existait pas dans les schémas anciens.
• 7:37
  On va définir différents environnements.
• 7:38
  C'est-à-dire qu'on ne va pas tout de suite aller pousser l'application en production.
• 7:42
  Ça,
• 7:42
  c'est hors de question.
• 7:43
  On ne va pas,
• 7:44
  t'imagines,
• 7:44
  si tu as 100 000 clients qui utilisent l'application,
• 7:46
  bim,
• 7:47
  tu as une release qui tombe,
• 7:48
  il y a tout qui change.
• 7:49
  Enfin non,
• 7:49
  c'est impossible de faire ça.
• 7:51
  Donc,
• 7:51
  on va d'abord l'envoyer sur un environnement,
• 7:53
  par exemple,
• 7:53
  de développement.
• 7:54
  L'environnement de développement,
• 7:55
  ça va permettre aux développeurs qui viennent de faire sa modification de la voir en temps réel,
• 8:00
  de pouvoir vérifier si,
• 8:02
  malgré les tests qui ont été faits avant,
• 8:04
  quand il y a un humain qui est derrière,
• 8:05
  ça fonctionne bien.
• 8:06
  Est-ce qu'on pourrait rappeler un bac à sable ou pas ?
• 8:08
  Oui,
• 8:09
  absolument.
• 8:10
  Alors,
• 8:10
  l'environnement de dev,
• 8:11
  il a plusieurs noms.
• 8:11
  On l'appelle bac à sable,
• 8:13
  sandbox en anglais,
• 8:14
  dev,
• 8:15
  recette,
• 8:16
  tout ce qui n'est pas en fait les environnements suivants qui sont la pré-prod et la prod.
• 8:20
  L'environnement de pré-production,
• 8:22
  c'est un environnement qu'on souhaite être au plus proche de la production.
• 8:25
  On va monter le même stockage,
• 8:28
  on va prendre des données qu'on va anonymiser avant,
• 8:31
  mais qui seront un ensemble de données qui est au plus proche de la production.
• 8:34
  Alors que dans un environnement de développement,
• 8:35
  on ne va pas avoir de données du tout,
• 8:36
  par exemple.
• 8:37
  Sur l'environnement de pré-prod,
• 8:39
  c'est là où potentiellement les product owners,
• 8:42
  les chefs produits,
• 8:44
  ceux qui ont réfléchi l'application avec les développeurs,
• 8:49
  peuvent tester.
• 8:49
  La partie assurance qualité dont je parlais avant,
• 8:52
  c'est la casquette de tous ces gens-là,
• 8:53
  justement.
• 8:54
  vérifier,
• 8:56
  tu connais aussi le sujet de toute façon,
• 8:58
  tu y as été confronté,
• 8:59
  donc c'est faire tester à ceux qui n'ont pas le nez dedans,
• 9:03
  donc pas les développeurs,
• 9:04
  pas les Ops,
• 9:05
  comme on les appelle,
• 9:06
  c'est le nouveau nom des administrateurs système,
• 9:08
  on les appelle les Ops,
• 9:10
  faire tester tout ça.
• 9:11
  Et quand c'est validé,
• 9:12
  là on a encore deux choix pour la mise en production,
• 9:14
  c'est soit on a une décision qui dit,
• 9:17
  ok,
• 9:18
  on a tout validé avec des équipes,
• 9:19
  il y a un comité qui est passé,
• 9:21
  fond.
• 9:22
  valide la mise en production etc etc on y va tout de suite en prod ou alors on fait ce qu'on appelle un ab test ça tu connais aussi la bête est voilà et ben on fait de la bête est côté des bobs aussi père on a les outils qui nous permettent en fait de déployer une
• 9:38
  environnement de production bis je dirais à côté et les outils d'infrastructures qui permettent quand un utilisateur d'arriver sur l'application il va être redirigé soit sur l'un soit sur l'autre de manière transparente là on le voit notamment sur nos applications réseaux sociaux
• 9:51
  Quand ils sortent des nouvelles fonctionnalités et qu'on dit à quelqu'un,
• 9:57
  à nos collègues,
• 9:59
  « Ah tiens,
• 9:59
  t'as vu,
• 9:59
  ils ont sorti ça ? »
• 10:00
  et que le collègue dit...
• 10:01
  Tout à fait.
• 10:02
  Pas du tout,
• 10:02
  moi je n'ai pas du tout...
• 10:04
  C'est exactement ça.
• 10:04
  C'est ce que nous on est capable de faire aussi sur la partie DevOps.
• 10:07
  Et tu vois,
• 10:08
  quand tu as cette nouvelle fonctionnalité qui apparaît sur ton réseau social,
• 10:11
  tu n'as pas eu de notification qui t'a dit il faut vous connecter à tel endroit maintenant,
• 10:15
  c'est totalement transparent pour l'utilisateur.
• 10:18
  Et donc avec ces fameux A-B tests,
• 10:19
  on est capable aussi de récolter de la donnée sur des tests qui sont dans l'application pour dire là le parcours utilisateur,
• 10:26
  il n'a l'air pas dingue,
• 10:27
  peut-être qu'on va revenir à la version d'avant.
• 10:29
  Donc du coup on fait ce qu'on appelle un rollback.
• 10:32
  qui fait aussi partie du pipeline DevOps,
• 10:34
  le rollback permet de revenir à la version qu'on avait en production avant.
• 10:38
  Alors,
• 10:38
  c'est un schéma qui est applicable,
• 10:40
  même si tu n'as pas de DevOps.
• 10:42
  Le rollback peut s'apparenter à une restauration de sauvegarde.
• 10:44
  Ça marche.
• 10:45
  Mais là,
• 10:46
  le fait de rentrer dans cette philosophie,
• 10:48
  ça fait que le rollback est pris en compte pendant tout le pipeline et du coup,
• 10:50
  on a les leviers pour l'activer rapidement.
• 10:53
  Par exemple,
• 10:53
  tu vois que tu as un gros problème,
• 10:55
  que tout le monde,
• 10:56
  malgré tous les tests que tu as faits,
• 10:57
  les gens qui ont vérifié...
• 10:58
  Et en fait,
• 10:59
  en production,
• 10:59
  tu commences à recevoir des appels de tous tes clients parce qu'il n'y a rien qui va.
• 11:03
  Tu cliques sur un bouton,
• 11:03
  tu passes à la version d'avant et hop,
• 11:04
  on peut se reposer et réfléchir à la suite.
• 11:07
  Oui,
• 11:07
  et ça,
• 11:07
  c'est la philosophie DevOps.
• 11:08
  Et ça,
• 11:08
  c'est la philosophie DevOps.
• 11:10
  J'ai une question sur ce que tu disais tout à l'heure.
• 11:14
  Il y a un truc qui me titille un peu.
• 11:16
  Il y a des fois,
• 11:17
  et on peut y être confronté en tant qu'utilisateur d'une application,
• 11:22
  tout d'un coup,
• 11:23
  on se connecte ou alors il y a plein de gens qui se connectent sur un site web ou une application parce que...
• 11:28
  il y a eu une énorme pub télé,
• 11:29
  parce qu'il y a eu un énorme influenceur qui a fait quelque chose.
• 11:32
  On se connecte et là,
• 11:33
  il n'y a plus rien.
• 11:34
  Absolument.
• 11:35
  Normalement,
• 11:36
  si on a une philosophie de DevOps,
• 11:37
  ça ne devrait pas arriver ?
• 11:38
  Ça ne devrait pas arriver.
• 11:40
  Est-ce que tu peux un peu nous expliquer pourquoi,
• 11:42
  à un moment donné,
• 11:44
  c'est l'écran noir sur les utilisateurs,
• 11:47
  les consommateurs ?
• 11:48
  Pour bien comprendre comment on pallie ce problème,
• 11:50
  il faut revenir sur cette fameuse notion de conteneur.
• 11:53
  La notion de conteneur,
• 11:54
  c'est...
• 11:55
  Quand on déploie une application sans cette fameuse containerisation,
• 11:59
  une application ne fonctionne pas nativement toute seule.
• 12:01
  Elle a besoin de dépendance.
• 12:02
  Des dépendances,
• 12:03
  on appelle ça de temps en temps des librairies système qui permettent par exemple de faciliter la connexion à un actif directorique.
• 12:12
  Le développeur ne va pas s'amuser à refaire cette intelligence par lui-même,
• 12:16
  il va se baser sur le travail existant de quelqu'un et il va l'intégrer dans son application.
• 12:20
  Ça devient une dépendance.
• 12:22
  En fonction de là où on va déployer l'application qu'on vient de créer avec ses dépendances,
• 12:26
  tu vas peut-être te retrouver sur une infrastructure qui va tout de suite avoir les dépendances et une autre infrastructure qui ne l'aura pas.
• 12:33
  Du coup,
• 12:34
  il y a un moment où ton application va marcher et un moment où elle ne va pas marcher du tout.
• 12:37
  Pour pallier ce problème,
• 12:39
  la conteneurisation,
• 12:40
  ça veut dire qu'on va prendre notre code source applicatif et on va prendre aussi toutes ses dépendances avec et on va les mettre dans une boîte.
• 12:48
  Et cette boîte-là,
• 12:48
  du coup,
• 12:49
  elle devient complètement autonome.
• 12:51
  Elle ne repose que sur un logiciel qui permet d'exécuter ce qui est à l'intérieur de ce conteneur-là.
• 12:57
  Et ce logiciel,
• 12:58
  il est uniforme,
• 12:59
  il peut s'installer à peu près partout.
• 13:00
  À partir du moment où le logiciel,
• 13:02
  dont vous avez forcément entendu parler,
• 13:03
  s'appelle Docker.
• 13:04
  Alors,
• 13:05
  Docker en est un parmi beaucoup,
• 13:06
  mais c'est le plus connu en tout cas sur le grand public.
• 13:09
  À partir du moment où tu as une infrastructure qui possède Docker,
• 13:12
  tu es capable de faire tourner ton conteneur partout.
• 13:15
  De manière uniforme,
• 13:16
  de manière totalement agnostique de l'infrastructure qui est en dessous.
• 13:20
  et de manière répétable,
• 13:21
  du coup.
• 13:21
  C'est ça qui est hyper intéressant.
• 13:23
  Étant donné que l'application est embarquée avec toutes ses dépendances,
• 13:26
  tu es capable de multiplier les instances de ton application à côté d'elle-même pour justement,
• 13:33
  par exemple,
• 13:33
  absorber de la charge.
• 13:35
  Donc en fait,
• 13:36
  les outils DevOps qu'on a aujourd'hui,
• 13:39
  ils vont aller poser des sondes autour de l'application,
• 13:42
  notamment sur le trafic qui va arriver dessus,
• 13:45
  et à partir d'un certain seuil de trafic,
• 13:47
  va décider tout seul de créer une copie de l'application.
• 13:50
  Pour absorber la charge,
• 13:51
  absorber le pic,
• 13:52
  et quand le pic redescend,
• 13:53
  supprimer les copies pour n'en avoir plus qu'une ou deux ou trois,
• 13:56
  ça dépend de ce que tu te fixes en seuil bas,
• 13:59
  et limiter du coup aussi les coûts d'infrastructure.
• 14:01
  Parce que tu pourrais te dire,
• 14:03
  je suis un site e-commerce qui fait beaucoup de ventes,
• 14:06
  je ne prends pas de risque,
• 14:07
  et sur les 365 jours de l'année,
• 14:09
  je mets beaucoup de copies de mon application,
• 14:11
  mais à la fin la facture elle est...
• 14:13
  Alors qu'il faut mieux le faire peut-être au moment de Noël ou à un autre moment.
• 14:18
  Et donc ce principe-là a un nom,
• 14:20
  ça s'appelle la scalabilité horizontale.
• 14:23
  J'ai dit bien horizontale parce qu'on a aussi la scalabilité verticale.
• 14:26
  Mais on va y revenir après.
• 14:29
  Aujourd'hui,
• 14:30
  avant qu'on passe à tous ces termes techniques,
• 14:32
  parce que là tu nous fais un peu du teasing sur plein de termes techniques,
• 14:36
  pourquoi aujourd'hui on ne peut plus se passer de DevOps ?
• 14:40
  Alors aujourd'hui...
• 14:42
  On ne peut plus se passer de DevOps,
• 14:43
  ou en tout cas c'est difficile de faire autrement,
• 14:46
  parce qu'on a des enjeux,
• 14:49
  notamment au niveau de la sécurité des données,
• 14:52
  de la cybersécurité au global d'une application,
• 14:56
  où on ne peut plus se permettre de poser une application.
• 14:59
  ou de faire des modifications de code dans une application sans contrôle,
• 15:02
  sans test,
• 15:03
  sans vérification,
• 15:04
  parce qu'on s'expose tout de suite à des schémas de fuite de données,
• 15:08
  de failles de sécurité qui sont exploitées.
• 15:10
  Avec l'arrivée de l'IA,
• 15:12
  ça peut aller très très vite aussi.
• 15:14
  Donc c'est presque vital d'avoir cette philosophie DevOps.
• 15:19
  Ça ne veut pas dire qu'il faut avoir une équipe qui est dédiée à ça,
• 15:21
  mais il faut au moins sensibiliser les développeurs s'il y a une équipe de développement et une équipe infra.
• 15:28
  les sensibiliser à cette philosophie de
• 15:30
  DevOps by Design et même aujourd'hui en 2026 de Security by Design.
• 15:35
  Vraiment,
• 15:35
  on fait très attention à ça.
• 15:37
  C'est difficile de passer à côté aujourd'hui,
• 15:39
  clairement.
• 15:40
  Et il y a eu un avènement du DevOps.
• 15:42
  Je vais avoir une question là-dessus,
• 15:44
  c'est comment tu as atterri sur le DevOps,
• 15:45
  parce que je pense que ça intéressera beaucoup de monde.
• 15:48
  Mais il y a eu un avènement du DevOps parce qu'il y a aussi de plus en plus d'applications qui sont en mode SaaS.
• 15:53
  Oui.
• 15:53
  application sur ton smartphone,
• 15:56
  etc.
• 15:57
  Et ça,
• 15:57
  je pense que ça a changé la donne.
• 16:00
  Il faut prendre un exemple qui parlera peut-être un peu plus à tout le monde.
• 16:05
  C'est,
• 16:06
  et tu l'as cité,
• 16:07
  c'est une application sur ton smartphone.
• 16:10
  Peu importe ce qu'elle fait.
• 16:11
  Disons une calculatrice,
• 16:12
  toute bête.
• 16:13
  Ton développeur,
• 16:14
  il va créer sa première calculatrice avec son code sur son ordinateur.
• 16:18
  Il va faire des simulations,
• 16:19
  par exemple d'iPhone,
• 16:20
  sur son ordi pour vérifier que son application marche bien.
• 16:22
  et au moment où il va...
• 16:23
  avoir besoin d'un vrai iPhone pour voir comment ça se comporte sur un vrai téléphone.
• 16:29
  Là déjà,
• 16:29
  si on fait l'analogie,
• 16:31
  l'environnement de développement,
• 16:32
  c'est son PC et la pré-prod,
• 16:34
  c'est son vrai téléphone.
• 16:35
  Déjà,
• 16:35
  on est dedans.
• 16:37
  Ensuite,
• 16:38
  le développeur tout seul,
• 16:39
  alors qu'il ait une équipe DevOps ou pas,
• 16:40
  mais imaginons qu'il soit déjà sensibilisé à la philosophie DevOps qui n'est pas forcément une équipe infra,
• 16:44
  ça peut être un auto-entrepreneur par exemple,
• 16:47
  il va commencer à faire ses tests.
• 16:48
  Alors ça,
• 16:48
  il n'y a rien de compliqué dans la mise en place.
• 16:51
  Mais surtout...
• 16:52
  Il va vouloir pousser son application sur les stores pour que les gens la téléchargent.
• 16:56
  Voilà,
• 16:56
  logique.
• 16:57
  Donc toi tu reçois l'application,
• 16:58
  tu la testes,
• 16:59
  tu dis que tu es en attente d'une mise à jour parce que je ne sais pas,
• 17:01
  il te manque la fonction diviser sur ta calculatrice.
• 17:03
  C'est un peu bête,
• 17:03
  mais bon,
• 17:04
  dans le développeur,
• 17:05
  dans son focus,
• 17:06
  peut-être qu'il a oublié.
• 17:07
  Ça peut arriver.
• 17:08
  Et donc du coup,
• 17:09
  tu vas contacter le développeur pour lui dire « Écoute,
• 17:11
  il manque la fonction division dans ton application.
• 17:14
  Est-ce que tu peux la rajouter dans ta prochaine mise à jour ? »
• 17:16
  Il va te dire « Ok,
• 17:16
  je travaille dessus. »
• 17:18
  Sans philosophie DevOps,
• 17:20
  ce « je travaille dessus »
• 17:21
  peut durer de une semaine à six mois en fonction de comment le développeur y travaille.
• 17:25
  Et là,
• 17:25
  il y a autant de façons de travailler qu'il y a de développeurs dans le monde.
• 17:29
  Donc tu ne sais jamais,
• 17:30
  tu es juste en attente.
• 17:31
  Avec une philosophie DevOps,
• 17:33
  tu peux avoir,
• 17:34
  je ne dirais pas un estimatif,
• 17:36
  mais te dire qu'avec tous les outils qui seront à la disposition du développeur,
• 17:41
  il va itérer tellement rapidement et de manière tellement automatique que lui,
• 17:44
  tout ce qu'il aura à faire finalement,
• 17:46
  c'est ouvrir son code source.
• 17:47
  rajouter sa fonction division,
• 17:49
  enregistrer et après ça part dans le tunnel et deux heures après,
• 17:53
  ta mise à jour elle arrive sur ton app store,
• 17:55
  tu as juste à l'installer et c'est terminé.
• 17:56
  Donc on a aussi une dynamique de je déploie plus vite,
• 18:00
  j'ai un time to market qui est vachement réduit.
• 18:02
  Alors ça c'est encore,
• 18:04
  tu le disais tout à l'heure aux personnes type Product Owner de définir un peu le cycle de release qu'ils veulent pour leur application.
• 18:10
  Il y en a qui itèrent jusqu'à 15 releases par jour,
• 18:13
  ça arrive.
• 18:14
  D'autres qui bloquent des cycles en disant qu'on fait des mises en production que le jeudi entre 16h et 17h,
• 18:19
  par exemple.
• 18:20
  Mais en tout cas,
• 18:21
  on voit avec l'avènement du DevOps que le time to market est réduit parce que les développeurs peuvent produire plus vite,
• 18:28
  plus sereinement et de manière plus sécurisée.
• 18:30
  Et ça,
• 18:30
  ça vient aussi un peu de la méthode agile.
• 18:32
  Un peu,
• 18:32
  beaucoup même.
• 18:33
  Parce que du coup,
• 18:34
  la méthode agile,
• 18:35
  la base de résolution des problèmes de la méthode agile,
• 18:37
  c'est les user stories.
• 18:38
  Et les user stories,
• 18:39
  ça parle beaucoup aux développeurs.
• 18:41
  J'ai un utilisateur qui n'arrive pas à faire ça.
• 18:43
  Tu donnes ça à un développeur,
• 18:45
  il te fait ta feature qui débloque le problème initial.
• 18:49
  Après,
• 18:49
  ça part dans le pipeline et du coup,
• 18:51
  le ticket agile,
• 18:52
  il est passé d'une colonne à l'autre en deux secondes.
• 18:55
  Donc,
• 18:55
  on ne peut pas parler aujourd'hui de DevOps sans parler de containerisation.
• 18:59
  Est-ce que tu peux nous en dire un petit peu plus sur la containerisation et comment au quotidien ça se schématise ?
• 19:06
  Alors,
• 19:06
  la containerisation,
• 19:07
  c'est devenu un standard aujourd'hui.
• 19:10
  C'est une méthode qui permet d'empacter.
• 19:12
  une application,
• 19:13
  ses dépendances et son environnement d'exécution qu'on appelle vulgairement un système d'exploitation,
• 19:19
  dans une boîte qui est un format standardisé qu'on va pouvoir déployer à peu près où on veut sur n'importe quelle infra à condition que l'infra soit prête pour accueillir ses conteneurs.
• 19:30
  Et là,
• 19:31
  l'intégralité des acteurs du cloud permet aujourd'hui d'accueillir des conteneurs sans avoir à réfléchir,
• 19:37
  sans que le développeur ait besoin de se poser la question
• 19:39
  Deux,
• 19:39
  je vais prendre une machine virtuelle qui fait tant de CPU,
• 19:42
  tant de RAM,
• 19:42
  tant de stockage.
• 19:43
  Non,
• 19:43
  non,
• 19:43
  il a juste à envoyer son conteneur.
• 19:45
  Le conteneur est mis en production du côté de l'acteur du cloud avec des paramètres,
• 19:50
  on en parlait tout à l'heure de scalabilité,
• 19:52
  de certificat SSL pour protéger l'application,
• 19:55
  on va lui demander sur quel nom de domaine.
• 19:57
  Tout ça,
• 19:57
  ça dépend de comment fonctionne le cloud qui est derrière,
• 20:00
  mais en tout cas,
• 20:00
  le schéma est le même,
• 20:01
  on vient déposer un conteneur.
• 20:02
  Donc le développeur maîtrise la technologie de containerisation,
• 20:05
  il sait comment ça fonctionne,
• 20:07
  il comprend comment il doit construire.
• 20:09
  Là,
• 20:09
  la philosophie DevOps peut venir intervenir en insufflant les bonnes pratiques de containerisation pour le développeur.
• 20:14
  Parce que le but,
• 20:15
  c'est que,
• 20:16
  étant donné qu'on se retrouve avec une enveloppe dont l'application à l'intérieur ne va représenter qu'une fraction de tout ce qui est embarqué par le conteneur,
• 20:23
  on essaye de faire des économies de poids et donc de ne pas embarquer dans ce conteneur-là des choses qui ne vont servir à rien pour l'exécution de l'application.
• 20:32
  Donc nous aussi,
• 20:33
  on a un rôle auprès du développeur pour lui dire,
• 20:36
  là,
• 20:36
  tu as peut-être tenté d'embarquer quelque chose qui ne va pas servir.
• 20:40
  Du coup,
• 20:40
  on te conseille de le supprimer.
• 20:41
  Tu n'as besoin fonctionnellement que de ça,
• 20:43
  ça et ça.
• 20:43
  Et ton application,
• 20:44
  elle pourra fonctionner.
• 20:45
  Est-ce que ça aide aussi le côté un peu numérique responsable ?
• 20:50
  Forcément.
• 20:52
  Forcément,
• 20:52
  parce que l'aspect…
• 20:53
  Là,
• 20:53
  on dirait que j'ai posé une question qui était sur le papier.
• 20:57
  Alors,
• 20:57
  pas du tout.
• 20:57
  Ce n'est pas du tout naturel.
• 20:59
  Prêt ou dépourvu.
• 21:03
  Ça fait partie,
• 21:05
  c'est un des axes d'études du numérique responsable,
• 21:07
  qui est de limiter l'impact environnemental.
• 21:10
  Alors,
• 21:10
  on parle souvent de l'impact environnemental du matériel,
• 21:12
  mais ça peut aussi prendre en compte les services et les applications.
• 21:16
  Le fait de réduire la taille d'une application containerisée,
• 21:19
  ça fait qu'elle va consommer moins d'espace.
• 21:21
  Plus égal.
• 21:22
  Voilà,
• 21:23
  exactement sur l'infrastructure sur laquelle on va la déployer.
• 21:26
  Et quand on va scaler cette application dans le futur,
• 21:30
  on va consommer moins de ressources de manière exponentielle,
• 21:33
  ce qui a forcément un impact sur ce côté-là.
• 21:36
  Donc oui,
• 21:37
  c'est une petite goutte sur le travail que représente tout le numérique responsable,
• 21:42
  mais par contre,
• 21:42
  ça a un impact.
• 21:44
  Et en quoi la containerisation facilite l'intégration continue ou le développement continu d'une application ?
• 21:50
  Ce que je le disais tout à l'heure,
• 21:52
  c'est un standard.
• 21:53
  Il n'y a pas
• 21:53
  36 manières de faire des containers.
• 21:56
  Il y a un standard.
• 21:57
  Alors,
• 21:57
  tout à l'heure,
• 21:58
  je parlais de Docker qui est...
• 22:00
  un environnement d'exécution de conteneurs.
• 22:02
  Il y en a d'autres,
• 22:03
  il y a conteneur D par exemple,
• 22:04
  qui en est un second,
• 22:05
  mais si tu veux,
• 22:07
  le format qui est utilisé par ces conteneurs,
• 22:10
  c'est un standard en lui-même qui s'appelle Spoiler OCI,
• 22:13
  pour Open Container Interface.
• 22:15
  Ah oui,
• 22:15
  on est partout.
• 22:16
  Incroyable.
• 22:17
  Et donc ce standard-là,
• 22:18
  il est utilisé par tous les programmes qui font tourner des conteneurs et qui dit standard,
• 22:24
  dit schéma de répétabilité.
• 22:26
  qui est absolument déployé partout.
• 22:29
  Il n'y a pas de conteneurisation sans respect de ce standard OCI.
• 22:33
  Ok.
• 22:34
  Et c'est un modèle open source ?
• 22:36
  Comment ça fonctionne ?
• 22:38
  C'est un modèle qui est évidemment open source.
• 22:40
  C'est un modèle qui a été porté...
• 22:41
  par des acteurs historiques de ce qu'on appelle l'informatique cloud native,
• 22:47
  toute la philosophie de containerisation.
• 22:49
  Alors,
• 22:49
  c'est un peu,
• 22:51
  c'est pas forcément,
• 22:51
  c'est très lié au DevOps,
• 22:52
  évidemment,
• 22:53
  mais c'est deux,
• 22:54
  je dirais,
• 22:54
  deux verticales qui sont quand même séparées.
• 22:57
  quand on parle de cloud native,
• 22:58
  on parle de toutes les technologies qui gravitent autour de la containerisation et de la scalabilité des applications dans le cloud.
• 23:06
  Donc évidemment,
• 23:06
  la communauté sous-jacente,
• 23:08
  elle est pour le partage,
• 23:10
  donc la majorité,
• 23:11
  si ce n'est pas toutes,
• 23:13
  tous ces outils qui sont utilisés dans le cloud native sont open source,
• 23:17
  y compris les briques fondamentales type le standard OCI.
• 23:19
  Ok,
• 23:20
  donc si on revient,
• 23:22
  cloud native,
• 23:23
  Dans le clone natif,
• 23:24
  il y a conténérisation.
• 23:26
  il y a DevOps,
• 23:27
  forcément,
• 23:28
  puisque quand on parle de cloud natif,
• 23:30
  on parle de développer une application qui,
• 23:33
  quoi qu'il en soit,
• 23:34
  sera dans le cloud et de penser son application en mode,
• 23:37
  elle va être en SaaS.
• 23:38
  Exactement.
• 23:39
  C'est exactement le but.
• 23:41
  Alors,
• 23:41
  il y a évidemment,
• 23:41
  tu t'en doutes,
• 23:42
  des petites divergences à droite,
• 23:43
  à gauche,
• 23:44
  selon les use cases,
• 23:46
  mais en tout cas,
• 23:47
  le schéma reste toujours le même.
• 23:49
  Respecter ce pipeline DevOps dont on a parlé tout à l'heure,
• 23:52
  déployer l'application quelque part,
• 23:54
  et effectivement,
• 23:55
  tu le soulignes,
• 23:55
  Je vais même rebondir.
• 23:56
  rebondir là-dessus.
• 23:57
  Quand on parle d'applications en SaaS,
• 23:58
  il y a quelque chose auquel on ne pense pas forcément,
• 24:01
  mais c'est souvent des applications web.
• 24:03
  On parle d'applications qui sont accessibles par Internet,
• 24:05
  soit par un site web,
• 24:07
  soit par une application de smartphone qui,
• 24:09
  en fait,
• 24:09
  elle-même,
• 24:10
  va se connecter derrière un site web.
• 24:11
  Donc,
• 24:11
  c'est souvent de la technologie du web.
• 24:14
  Ok.
• 24:16
  On a parlé de containerisation,
• 24:17
  on va parler de stockage S3.
• 24:20
  Si je dis stockage objet,
• 24:22
  je parle de la même chose ?
• 24:23
  Oui.
• 24:26
  Ça c'est poli,
• 24:26
  mais ça veut dire que ce n'est pas tout à fait la même chose.
• 24:28
  On peut préciser.
• 24:29
  Tu nous expliqueras les deux.
• 24:32
  Est-ce que tu peux nous dire,
• 24:34
  stockage S3,
• 24:35
  stockage objet,
• 24:37
  qu'est-ce que ça veut dire et quel est le lien avec la philosophie DevOps ?
• 24:40
  Alors,
• 24:41
  le stockage objet,
• 24:42
  c'est le type de stockage.
• 24:44
  Et S3...
• 24:45
  c'est une implémentation de ce type de stockage.
• 24:47
  Waouh !
• 24:48
  Voilà.
• 24:50
  En gros,
• 24:50
  le stockage objet vient en opposition au stockage qu'on a tous connu et qu'on connaît tous aujourd'hui,
• 24:56
  qui est le stockage par bloc,
• 24:58
  qui est ce que ton ordinateur utilise.
• 25:02
  Un système de fichiers dans un disque dur dans lequel tu peux naviguer par dossier,
• 25:06
  qui est utilisé par les applications de ton PC,
• 25:08
  mais qui a une adhérence très forte avec le matériel sur lequel il tourne.
• 25:13
  Exemple tout bête,
• 25:13
  tu enlèves le disque dur de ton ordi,
• 25:15
  t'as plus d'ordi.
• 25:16
  Voilà,
• 25:16
  je veux dire,
• 25:17
  je peux pas faire plus simple.
• 25:19
  Le stockage objet,
• 25:20
  c'est un stockage qui a été pensé pour ce fameux monde du cloud natif,
• 25:24
  où là,
• 25:25
  on n'est plus dans une philosophie d'adhérence au matériel d'infrastructure sur lequel on va déployer l'application.
• 25:31
  Si on était dans ce schéma-là,
• 25:33
  ni le développeur ni les admin systems qui sont derrière vont aller se poser la question de mon application a besoin de stockage.
• 25:40
  Il faut que je pense à l'avance,
• 25:41
  à me dire attention l'infra sur laquelle j'arrive,
• 25:43
  elle a tel type de disque dur,
• 25:45
  elle a tel type de point de montage.
• 25:47
  Non,
• 25:47
  non,
• 25:47
  ce n'est absolument pas une question à se poser.
• 25:49
  Il faut que l'application puisse utiliser un stockage qui est un standard aussi et qui soit disponible.
• 25:55
  Disponible partout.
• 25:56
  Et aujourd'hui,
• 25:56
  qui dit disponible partout,
• 25:58
  dit sur Internet.
• 25:59
  Donc,
• 26:00
  technologie web.
• 26:00
  On y revient toujours.
• 26:02
  Donc,
• 26:02
  le stockage objet,
• 26:03
  c'est une série,
• 26:04
  en fait,
• 26:05
  de couches d'abstraction sur du stockage physique classique,
• 26:08
  des disques durs,
• 26:08
  mais qui vont permettre...
• 26:10
  à un développeur,
• 26:10
  un administrateur,
• 26:11
  un personnel technique,
• 26:12
  de pouvoir interagir avec du stockage,
• 26:14
  donc créer des fichiers,
• 26:15
  les modifier,
• 26:16
  les déplacer,
• 26:17
  les renommer,
• 26:17
  leur mettre des attributs,
• 26:18
  les protéger,
• 26:19
  tout ce qu'on fait sur un système de fichiers classique,
• 26:21
  mais au travers d'une interface web,
• 26:24
  au travers d'une API,
• 26:25
  pour le coup.
• 26:26
  En quoi cette partie stockage S3,
• 26:29
  c'est ça,
• 26:32
  stockage S3,
• 26:33
  je relis bien mes notes,
• 26:33
  parce que vu que c'est technique,
• 26:35
  je ne voudrais pas avoir des commentaires en me disant attention,
• 26:37
  ce n'est pas les bons termes techniques.
• 26:39
  En quoi elle facilite le travail de la philosophie d'Elobs ?
• 26:43
  Alors,
• 26:45
  pour une raison toute simple,
• 26:46
  c'est que le stockage objet est donc S3,
• 26:48
  si on rebondit sur S3,
• 26:50
  S3 c'est l'implémentation de ce stockage-là.
• 26:52
  C'est un standard d'API pour utiliser ce stockage objet.
• 26:55
  C'est écrit par...
• 26:56
  Amazon et
• 26:58
  Amazon a rendu la conception de cette API open source ce qui a permis en fait à des éditeurs de solutions de stockage de proposer leur implémentation de cette API au standard S3.
• 27:12
  C'est génial parce que ça veut dire que qui voulait utiliser du stockage objet était obligé d'aller chez Amazon parce que c'était eux qui proposaient ce standard-là et qui était le meilleur.
• 27:24
  Mais du coup,
• 27:24
  le fait de l'avoir rendu ouvert a permis de pouvoir l'installer chez soi,
• 27:28
  de pouvoir avoir des implémentations chez des acteurs privés du cloud.
• 27:32
  Souverains.
• 27:34
  Souverains,
• 27:34
  exactement,
• 27:35
  et d'avoir un standard qui permet que la même API qu'on utilisait chez Amazon.
• 27:42
  pour exploiter ce stockage,
• 27:44
  on va la retrouver chez un autre acteur
• 27:46
  100% compatible.
• 27:47
  Et là,
• 27:47
  on en revient à cette couche.
• 27:48
  Alors,
• 27:49
  je parlais du standard OCI,
• 27:50
  qui était le standard de containerisation.
• 27:52
  Le standard S3,
• 27:53
  du coup,
• 27:53
  est le standard de stockage.
• 27:54
  Ce qui fait qu'encore une fois,
• 27:56
  peu importe l'endroit où on va aller déployer notre application,
• 27:59
  à partir du moment où ce fameux stockage S3,
• 28:02
  qui,
• 28:02
  je le rappelle,
• 28:03
  est sur Internet,
• 28:04
  donc c'est un lien HTTPS pour accéder à un fichier,
• 28:07
  à partir du moment où ce point-là,
• 28:09
  il est disponible pour l'application,
• 28:12
  Du coup,
• 28:12
  son stockage est disponible.
• 28:14
  Donc,
• 28:14
  on devient aussi agnostique de là où on va stocker les données.
• 28:18
  Et ça,
• 28:18
  c'est génial.
• 28:19
  Excellent.
• 28:21
  Si on se met côté entreprise,
• 28:25
  si une entreprise a une application,
• 28:29
  a développé son propre RP via un partenaire ou pas,
• 28:34
  si elle a développé son site web,
• 28:37
  son portail client,
• 28:38
  etc.
• 28:40
  et qu'elle se dit,
• 28:42
  je pense qu'il faut que je sois dans une philosophie DevOps parce que je me rends compte que j'ai des problèmes de cybersécurité,
• 28:48
  de performance,
• 28:49
  de test,
• 28:50
  de pré-prod,
• 28:51
  de bac à sable,
• 28:52
  etc.
• 28:53
  Par quoi elle doit commencer ?
• 28:55
  Alors souvent,
• 28:56
  elle va commencer par identifier un use case qui est répétable,
• 29:02
  c'est-à-dire une action qui est faite dans la journée 2,
• 29:05
  3,
• 29:06
  4 fois manuellement.
• 29:08
  Et quand on se rend compte en fait que cette action manuelle,
• 29:11
  elle a la possibilité d'être automatisée en jouant sur,
• 29:17
  alors ça peut être le déploiement d'une application,
• 29:18
  ça peut être le téléchargement ou l'upload de fichiers type CRM.
• 29:23
  CSV avec des données dedans.
• 29:24
  La génération de ces fichiers-là aussi,
• 29:26
  des fois il y a des gens encore qui remplissent des Excel à la main alors qu'on pourrait automatiser le remplissage de ces fichiers-là.
• 29:31
  Quand il y a un use case de ce type-là qui est identifié chez le client,
• 29:36
  c'est là qu'on peut commencer à enclencher la philosophie d'Azure.
• 29:38
  DevOps.
• 29:38
  Étudier la chose pour se dire la première étape,
• 29:41
  c'est comment on va automatiser cette tâche répétitive qui est redondante.
• 29:45
  Et là,
• 29:45
  je ne parle même pas de code applicatif.
• 29:47
  Ça peut vraiment être de la saisie de données.
• 29:49
  Juste,
• 29:50
  on est capable d'aller insuffler cette philosophie d'automatisation dans des tâches qui sont souvent rébarbatives.
• 29:58
  Mais en tout cas souvent...
• 29:59
  très répétitives et qui peuvent être ennuyantes du coup.
• 30:02
  Et justement pour toi,
• 30:04
  quelle est l'erreur la plus fréquente quand on se lance dans le DevOps ?
• 30:08
  Alors l'erreur elle vient...
• 30:10
  Tu souris.
• 30:11
  Ouais je souris parce que forcément quand bien même on est sur une communauté qui est largement open source et ouverte,
• 30:16
  il y a des acteurs qui veulent faire du business dessus donc ils vont développer beaucoup d'outils alors en SaaS souvent mais qui eux-mêmes suivent la philosophie DevOps on boucle la boucle toujours au final mais qui vont aller vendre BOUM
• 30:29
  des abonnements,
• 30:29
  vendre des prestations,
• 30:31
  miroir,
• 30:32
  tout est joli,
• 30:32
  on va venir chez vous,
• 30:33
  on va absolument tout automatiser,
• 30:35
  ça va être génial.
• 30:35
  Alors,
• 30:36
  c'est vrai que c'est génial parce que du coup,
• 30:37
  tu te dis,
• 30:38
  toutes mes saisies de données,
• 30:40
  toutes mes releases de codes applicatifs,
• 30:43
  tout ça,
• 30:43
  ça va être automatisé en un coup de cuillère à peau,
• 30:46
  mais derrière,
• 30:46
  l'entreprise,
• 30:47
  elle va quand même perdre le contrôle sur ce qui se passe.
• 30:49
  Ça va être confié finalement à un prestataire.
• 30:51
  Le prestataire,
• 30:52
  il va,
• 30:52
  alors c'est son rôle évidemment d'aider le client là-dedans.
• 30:55
  Donc pour moi,
• 30:56
  c'est mon point de vue personnel,
• 30:57
  c'est une erreur dans le sens où un...
• 30:59
  on perd un peu la maîtrise sur les processus qui sont mis en place chez le client.
• 31:03
  C'est-à-dire que lui,
• 31:03
  il avait l'habitude de faire comme ça,
• 31:05
  et il va avoir souscrit un abonnement à un logiciel tiers qui va lui,
• 31:11
  je ne vais pas dire lui mettre le bazar,
• 31:12
  mais qui va plutôt tout remettre d'équerre de manière automatique,
• 31:16
  mais sans forcément voir ce qui se passe en dessous.
• 31:18
  Alors,
• 31:19
  la finalité,
• 31:19
  elle est là,
• 31:20
  elle existe,
• 31:20
  et elle sera probablement très bonne.
• 31:23
  Mais par contre,
• 31:23
  le jour où il faudra défaire ce qui a été fait,
• 31:27
  parce qu'il y a eu un changement de système.
• 31:28
  un changement de technologie,
• 31:30
  là,
• 31:30
  il va y avoir de la friction.
• 31:32
  Donc,
• 31:32
  toi,
• 31:32
  tu es plutôt sur une philosophie,
• 31:35
  je pense,
• 31:35
  qui ressemble pas mal à la philosophie des hubs,
• 31:37
  sur du copilotage,
• 31:39
  de la procréation.
• 31:40
  Exactement.
• 31:40
  On prend le temps.
• 31:41
  On prend le temps,
• 31:42
  on y va étape par étape.
• 31:43
  On adresse d'abord des petits projets qui sont très identifiables par toutes les équipes.
• 31:50
  Et après,
• 31:50
  on s'attaque,
• 31:51
  on gravit la montagne petit à petit.
• 31:53
  La stratégie des petits pas.
• 31:54
  Nous,
• 31:54
  on adore parler de ça chez ECI.
• 31:57
  la stratégie des petits...
• 31:58
  petit pas,
• 31:59
  on y va,
• 31:59
  il faut y aller,
• 32:01
  mais petit à petit,
• 32:02
  pour que ça soit une réussite.
• 32:04
  Et surtout,
• 32:04
  tu as vu le nombre d'étapes qu'il y a dedans,
• 32:06
  tu ne peux pas arriver en une semaine et espérer tout implémenter tout de suite.
• 32:11
  On peut mettre les étapes les unes après les autres.
• 32:13
  Ne serait-ce que s'adresser à une équipe de développement qui n'a jamais fait de test,
• 32:17
  et leur mettre un pipeline de test,
• 32:19
  c'est déjà un grand pas en avant pour eux,
• 32:21
  parce que ça leur permettra d'avoir tout de suite un retour sur leur code en leur disant attention,
• 32:24
  ce que tu as fait là,
• 32:24
  ça ne marche pas.
• 32:26
  Et il y a beaucoup plus d'entreprises qu'on ne le pense qui sont dans le cas où il n'y a pas encore de test et il n'y a même pas un prémice de philosophie DevOps qui est insufflé chez les développeurs.
• 32:34
  Donc c'est pour ça vraiment petit à petit,
• 32:36
  on y va.
• 32:38
  Et concrètement dans ton métier au quotidien ?
• 32:41
  avec ton équipe.
• 32:43
  Tu nous l'as expliqué,
• 32:44
  faire des tests,
• 32:45
  ce n'est pas cliquer là,
• 32:46
  cliquer là,
• 32:47
  etc.
• 32:47
  Vous faites des tests automatisés.
• 32:50
  Vous êtes dans la création des modèles de tests.
• 32:54
  Après,
• 32:55
  ça part comme tel un script.
• 32:57
  Tu peux nous expliquer ça ?
• 33:01
  C'est...
• 33:02
  Alors,
• 33:03
  il y a une étape humaine qui est forcément nécessaire,
• 33:05
  parce que le code ne peut pas deviner tout seul ce qu'il doit faire finalement comme test.
• 33:09
  Alors aujourd'hui,
• 33:10
  avec l'IA,
• 33:11
  on peut faire des miracles.
• 33:13
  Mais évidemment,
• 33:13
  avant,
• 33:14
  il y avait une...
• 33:15
  Il y a toujours une dynamique dans laquelle l'OBS,
• 33:17
  le fameux OBS dont je parlais tout à l'heure,
• 33:19
  il doit avoir une appétence quand même pour le code applicatif.
• 33:22
  Parce que,
• 33:23
  pour implémenter des tests,
• 33:24
  alors que ce soit des bêtes tests de formatage de code,
• 33:28
  des tests un peu plus poussés,
• 33:29
  type les tests de non-régression,
• 33:30
  ou les fameux tests end-to-end,
• 33:32
  ces trois catégories.
• 33:34
  Si on doit rédiger ces fameux tests,
• 33:36
  il faut avoir à la fois connaissance métier de l'application qu'on est en train de traiter et à la fois connaissance un peu,
• 33:43
  à minima,
• 33:44
  du code sur lequel on est en train de travailler.
• 33:46
  Donc,
• 33:46
  c'est pour ça qu'on parle de
• 33:48
  DevOps, développeur opérationnel.
• 33:50
  Il y a une patte côté développement et il y a une patte côté admin system avec le côté Ops.
• 33:56
  Oui,
• 33:56
  c'est vraiment un 360.
• 33:59
  Oui,
• 33:59
  oui.
• 33:59
  Et même tu dis côté développeur,
• 34:02
  côté admin system,
• 34:05
  même côté fonctionnel,
• 34:07
  c'est ce que tu disais,
• 34:07
  métier.
• 34:08
  Oui.
• 34:08
  Prendre aussi l'application parce que si tu ne comprends pas l'application,
• 34:12
  les tests que tu vas produire,
• 34:14
  ils sont peut-être standards.
• 34:14
  Ok,
• 34:15
  tu as des tests standards.
• 34:15
  Oui,
• 34:15
  c'est ça,
• 34:15
  exactement.
• 34:16
  Mais tu vas aussi avoir des tests qui sont extrêmement liés à l'application.
• 34:19
  Oui,
• 34:19
  tout à fait.
• 34:19
  Est-ce que l'utilisateur va en faire ?
• 34:22
  C'est un côté qui est un très bon exemple.
• 34:27
  Je prends une application qu'on connaît bien chez Océan,
• 34:28
  Odoo.
• 34:29
  Par exemple,
• 34:30
  sur une équipe d'administration système,
• 34:33
  s'occuper d'ODU,
• 34:34
  ça va être s'occuper que l'infrastructure fonctionne et s'occuper que l'application ODU fonctionne de manière système.
• 34:42
  C'est-à-dire,
• 34:42
  on va vérifier que le service tourne et qu'il est OK.
• 34:45
  Et éventuellement,
• 34:46
  si on veut pousser un tout petit peu plus loin,
• 34:48
  on va mettre une sonde qui va vérifier que la page d'accueil de l'application ODU,
• 34:51
  elle répond.
• 34:52
  Mais on s'arrête là.
• 34:54
  On ne rentre pas dans l'application.
• 34:55
  Et là,
• 34:56
  ça peut devenir un point de friction.
• 34:57
  Parce que du coup,
• 34:58
  le développeur qui est de l'autre côté,
• 34:59
  qui va faire des choses sur Odoo,
• 35:01
  lui va se concentrer sur ce qu'il fait sur Odoo.
• 35:04
  Et tout ce qui se passe entre la page de login et son code à lui,
• 35:08
  dans ce schéma-là,
• 35:09
  il n'y a personne qui le vérifie.
• 35:10
  Donc ça peut être complètement cassé.
• 35:13
  Je veux dire,
• 35:13
  tu peux avoir ta page de login qui est là,
• 35:15
  sur laquelle tu peux taper ton login,
• 35:16
  ton mot de passe,
• 35:17
  mais par contre,
• 35:17
  quand tu appuies sur Entrée,
• 35:18
  derrière,
• 35:18
  il n'y a plus rien.
• 35:19
  Ça,
• 35:19
  ça arrive super souvent,
• 35:21
  vraiment super souvent.
• 35:23
  Donc,
• 35:24
  la philosophie
• 35:25
  DevOps dans cette optique-là,
• 35:28
  c'est d'aller un peu plus loin.
• 35:30
  On ne parle pas d'aller vraiment décortiquer chaque fonction d'ODU une par une,
• 35:34
  mais vraiment de faire des tests fonctionnels qui permettent de s'assurer que quand le développeur vient de livrer une nouvelle version de son code pour ODU,
• 35:41
  on n'a pas cassé le reste d'ODU.
• 35:43
  Donc,
• 35:43
  on va simuler une connexion sur ODU.
• 35:45
  On va aller ouvrir la comptabilité dans ODU,
• 35:48
  vérifier que ça s'affiche bien.
• 35:51
  Vraiment,
• 35:51
  c'est du test de surface.
• 35:53
  On vérifie juste que ça marche.
• 35:55
  Et le fait de connaître comment fonctionne Odoo,
• 35:57
  forcément,
• 35:57
  ça aide à rédiger les tests.
• 35:59
  Et ça,
• 35:59
  ça peut s'appliquer à peu près à n'importe quelle application à condition qu'on ait de la documentation qui permette de savoir comment fonctionne l'application.
• 36:07
  Et à partir de là,
• 36:07
  on est capable d'imaginer toutes sortes de tests différents.
• 36:11
  Je te dis que là,
• 36:13
  le paradigme dit qu'on va rester en surface pour vérifier que tout va bien.
• 36:16
  Après,
• 36:16
  il y a des équipes qui vont très très loin dans les tests.
• 36:18
  qui peuvent prendre jusqu'à une journée entière parce qu'on va tester vraiment chaque bouton de l'application pour être sûr qu'il y ait tout qui marche.
• 36:24
  Encore une fois,
• 36:25
  ça vient du pilotage qui est au-dessus,
• 36:27
  les product owners,
• 36:28
  savoir ce qu'ils veulent,
• 36:29
  mais on peut tout faire.
• 36:30
  Théoriquement,
• 36:31
  le champ des possibles est infini.
• 36:32
  On peut vraiment faire tous les types de tests.
• 36:33
  Tu peux créer des scripts de tests sur plein de choses.
• 36:37
  Un exemple qui est plutôt tiré de ces équipes d'assurance qualité,
• 36:41
  c'est quand tu fais une application en client final qui est intégralement web,
• 36:45
  un site e-commerce,
• 36:46
  un site de prestation,
• 36:49
  le simple fait de tester que ton application s'affiche n'est pas suffisant tu vas vouloir faire des tests sur différents navigateurs tu vas prendre Google Chrome d'un côté Firefox,
• 36:58
  Edge et en fait tu vas faire exactement les mêmes tests mais avec différents navigateurs et ça si ton application elle est lourde et que tu fais beaucoup de tests ça peut durer un temps donc ça dépend à quel niveau on met ce curseur de test justement mais théoriquement tout est faisable si je résume avant qu'on passe à la conclusion
• 37:15
  Normalement,
• 37:16
  quand on a une philosophie de DevOps,
• 37:17
  on ne devrait plus entendre
• 37:19
  « ça, ce n'est pas moi,
• 37:20
  c'est le développeur,
• 37:21
  ça,
• 37:21
  ce n'est pas moi,
• 37:21
  c'est l'admin système Ofra » .
• 37:24
  Absolument,
• 37:25
  parce que chaque étape est traçable,
• 37:26
  du coup,
• 37:27
  forcément.
• 37:28
  Il y a quelque chose qu'on n'a pas évoqué qui sort un peu du DevOps,
• 37:31
  mais qui vient quand même en base,
• 37:32
  c'est que la première chose qu'on va faire,
• 37:34
  c'est qu'on va mettre un outil de versionning de code.
• 37:36
  Donc,
• 37:36
  on va voir en fait qui a fait quelle modification.
• 37:38
  Donc déjà,
• 37:39
  ça,
• 37:39
  ça permet…
• 37:40
  Alors,
• 37:40
  le but,
• 37:40
  ce n'est pas de blâmer,
• 37:41
  mais c'est surtout de se retourner…
• 37:43
  vers la personne en disant,
• 37:43
  là,
• 37:44
  je vois que c'est toi qui as travaillé là-dessus,
• 37:46
  il faudra peut-être corriger ce truc-là,
• 37:47
  tu as l'air de mieux connaître que moi.
• 37:49
  Surtout ça.
• 37:50
  Et surtout,
• 37:52
  on est dans une philosophie dans laquelle on va intégrer en plus des tests.
• 37:56
  Alors les tests,
• 37:57
  c'est des choses qu'on met...
• 37:57
  permet à la construction de l'application.
• 38:00
  Mais une fois que l'application est en production,
• 38:01
  il faut quand même continuer à la surveiller.
• 38:03
  Et donc,
• 38:03
  du coup,
• 38:04
  dans cette philosophie,
• 38:05
  on va intégrer énormément de sondes applicatives qui vont pouvoir remonter elles-mêmes,
• 38:10
  déjà de l'historisation sur le comportement de l'application,
• 38:13
  les temps de réponse,
• 38:14
  est-ce que ça communique bien avec une base de données,
• 38:16
  par exemple,
• 38:18
  et des indicateurs,
• 38:19
  ça marche,
• 38:19
  ça ne marche pas,
• 38:20
  dans l'application.
• 38:20
  Oui,
• 38:21
  et puis aussi,
• 38:21
  vu qu'on est tous dépendants...
• 38:24
  des grands acteurs du marché et de leur mise à jour et forcément à un moment donné tu as créé des dépendances que tu disais tout à l'heure dans ta partie comptabilisation,
• 38:34
  de tester régulièrement ça permet aussi que quand on va pas le citer mais voilà l'entreprise mondiale qui fait beaucoup de mise à jour et sur lesquelles 90%
• 38:44
  des entreprises sont fait une mise à jour ça évite si tu as fait des tests et des scripts pour faire en sorte que ton application elle plante comme si elle était...
• 39:01
  C'est ça et à ça même deux choses différentes.
• 39:05
  La première,
• 39:06
  c'est que le fait d'avoir conteneurisé ton application.
• 39:09
  tu as verrouillé ces dépendances.
• 39:10
  Donc déjà,
• 39:11
  même si ton éditeur fait une mise à jour de ta dépendance,
• 39:14
  elle ne sera pas embarquée dans ton application parce que toi,
• 39:16
  tu as dit,
• 39:16
  moi,
• 39:16
  cette version-là dedans est point barre.
• 39:18
  Donc,
• 39:18
  tu es sûr que ça fonctionne avec.
• 39:19
  Oui,
• 39:19
  en fait,
• 39:19
  ce que tu as bloqué,
• 39:20
  c'est la version.
• 39:21
  Exactement.
• 39:22
  Et si ton éditeur fait une mise à jour,
• 39:24
  toute ta série de tests qui se passent avant va te permettre de voir si ton code fonctionne toujours avec la version mise à jour.
• 39:29
  Donc du coup,
• 39:30
  tu résous deux problèmes en un.
• 39:31
  Super intéressant.
• 39:34
  Si tu devais résumer avant qu'on passe,
• 39:36
  parce que j'en ai fait du teasing.
• 39:38
  de comment on atterrit dans le DevOps parce que moi ça m'intéresse si on devait résumer DevOps en une idée forte c'est une philosophie c'est une méthode de travail ce n'est surtout pas une stack technique
• 39:54
  Parce que le DevOps,
• 39:55
  ce n'est pas une série d'outils définis,
• 39:57
  ça peut être plein d'outils différents qui existent sur le marché,
• 39:59
  ou même des scripts,
• 40:01
  des bêtes scripts,
• 40:01
  qui permettent d'activer cette philosophie,
• 40:04
  et ce n'est pas un métier.
• 40:05
  C'est vraiment une méthode de travail.
• 40:09
  On s'entoure évidemment d'outils,
• 40:11
  mais c'est des idées,
• 40:12
  et c'est surtout très...
• 40:14
  très...
• 40:15
  comment je pourrais dire ça ?
• 40:16
  C'est très malléable en fonction du contexte dans lequel on veut appliquer cette philosophie.
• 40:21
  On ne va pas faire du DevOps de la même manière chez un client A et un client B.
• 40:25
  L'idée de base reste la même,
• 40:26
  avec les piliers qu'on a cités.
• 40:28
  Par contre,
• 40:28
  l'appliquer...
• 40:29
  de ces piliers là elle va différer tout à fait en fonction du contexte dans lequel on sera justement ben voilà la question de ce podcast et comment tu as atterri dans le devops à quel moment on se dit ça je vais faire du devops j'ai vraiment dit je vais être un
• 40:48
  g cyber j'ai un frère j'ai claude développeurs
• 40:58
  Qu'est-ce qui s'est passé dans ta vie ?
• 40:59
  Raconte-nous parce que je pense que tout le monde...
• 41:01
  Déjà t'as quel âge ?
• 41:03
  Alors moi j'ai 33 ans.
• 41:05
  Je suis 93.
• 41:07
  Ouais.
• 41:08
  Et j'ai été formé au CNRS pendant 4 ans où le DevOps n'existait pas du tout à l'époque.
• 41:16
  je faisais plutôt ce qui s'apparente aujourd'hui à de l'informatique interne là-bas.
• 41:19
  Et en sortie d'alternance,
• 41:20
  je fais mon alternance là-bas,
• 41:22
  quand je cherchais du travail à Paris,
• 41:24
  j'ai été recruté chez Mythique,
• 41:26
  site de rencontre.
• 41:27
  Alors Mythique,
• 41:28
  il faut savoir qu'à l'époque,
• 41:30
  c'est une plateforme européenne qui est opérée par les équipes en France,
• 41:34
  mais qui adresse du coup tous les sites de rencontre européens sur une seule et même plateforme qui était située en France.
• 41:40
  En fonction de là où tu te connectais,
• 41:43
  si tu te connectais en France,
• 41:44
  tu avais Mythique.
• 41:45
  .fr,
• 41:45
  si tu te connectais depuis les Pays-Bas,
• 41:46
  tu arrivais sur les mêmes serveurs,
• 41:48
  mais par contre,
• 41:49
  ça affichait devant toi la version néerlandaise,
• 41:51
  par exemple,
• 41:52
  de Mythique.
• 41:53
  Et quand j'ai découvert ça,
• 41:54
  je me suis dit,
• 41:54
  mais attends,
• 41:56
  c'est pas des petits humains derrière qui font en sorte que chaque personne arrive,
• 41:58
  il y a forcément quelque chose derrière.
• 42:00
  Et quand j'ai vu,
• 42:01
  en fait,
• 42:01
  l'infrastructure dont disposait Mythique,
• 42:04
  donc c'était des centaines de serveurs web qui avaient tous le même code,
• 42:09
  à la virgule près.
• 42:11
  Je me suis dit,
• 42:11
  de la même manière,
• 42:13
  c'est...
• 42:13
  pas un humain qui va s'amuser à chaque mise à jour à pousser sur chaque serveur unitaire le nouveau code,
• 42:19
  il y a forcément quelque chose qui existe pour déployer en masse,
• 42:22
  et c'est à ce moment-là que je suis tombé dedans,
• 42:25
  quand j'ai découvert que tu peux avoir des infrastructures qui étaient gargantuesques à partir du moment où tu as un standard que tu as défini avant pour tester,
• 42:34
  déployer,
• 42:35
  monitorer l'ensemble,
• 42:37
  du coup tu peux avoir une toute petite infra ou quelque chose d'énorme,
• 42:40
  ça se traite exactement de la même manière.
• 42:42
  Ça m'a passionné,
• 42:42
  je suis resté là-dedans.
• 42:44
  Après,
• 42:45
  j'ai déménagé à Strasbourg.
• 42:46
  Je suis arrivé chez OCI.
• 42:47
  Et du coup,
• 42:48
  voilà.
• 42:51
  Super.
• 42:53
  Donc,
• 42:53
  Amitik,
• 42:54
  tu as fait tomber amoureux du DevOps,
• 42:55
  on peut le dire.
• 42:56
  On peut le dire,
• 42:57
  oui.
• 42:58
  Je vais faire le teasing sur un autre podcast qu'on va faire ensemble.
• 43:02
  Comment va évoluer le DevOps dans les années,
• 43:06
  les mois,
• 43:06
  les années à venir ?
• 43:07
  Tout va tellement vite dans l'IT et dans le digital.
• 43:10
  Alors,
• 43:10
  c'est excellent teasing.
• 43:11
  Ça va beaucoup tourner autour de l'IA,
• 43:13
  c'est sûr et certain.
• 43:15
  Tout à l'heure,
• 43:15
  je citais pendant notre discussion que l'Ops devait avoir une appétence pour la partie de développement.
• 43:21
  Avec l'IA,
• 43:21
  ça va devenir de moins en moins vrai parce que l'IA deviendra la partie du cerveau de l'Ops qui s'occupera de voir comment le code fonctionne.
• 43:30
  Ça va permettre d'insuffler encore plus de puissance,
• 43:35
  si je peux dire ça comme ça,
• 43:36
  aux équipes qui font du DevOps.
• 43:38
  Parce que du coup,
• 43:38
  elles vont pouvoir adresser tout un tas de contextes différents,
• 43:42
  alors qu'aujourd'hui,
• 43:43
  tu as des DevOps qui sont plutôt spécialisés dans un,
• 43:46
  deux,
• 43:46
  trois langages de programmation de prédilection.
• 43:49
  Demain,
• 43:49
  avec l'IA,
• 43:50
  il n'y aura plus du tout cette barrière-là.
• 43:52
  On gardera cette philosophie de « je dois faire mes étapes DevOps » .
• 43:56
  Par contre,
• 43:57
  comment le code a été écrit à la base,
• 43:59
  on mettra une IA dessus qui nous conseillera en nous disant « là,
• 44:02
  le développeur a tenté de faire ça,
• 44:03
  il faudrait peut-être rajouter un test » .
• 44:06
  qui parle de cette fonction et on n'aura plus besoin de savoir comment le code se comporte parce qu'on aura une IA dessus.
• 44:11
  N'en dis pas plus.
• 44:12
  J'en dis pas plus.
• 44:13
  Il faut que les personnes regardent le futur podcast sur l'IA et le DevOps.
• 44:21
  Merci
• 44:21
  Louis, c'était passionnant le DevOps.
• 44:24
  Je pense que j'ai appris plein de choses,
• 44:26
  ça c'est sûr.
• 44:27
  J'espère que les personnes qui nous écoutent ont appris également beaucoup de choses mais je n'ai aucun doute là-dessus.
• 44:33
  Merci beaucoup.
• 44:35
  Et moi,
• 44:35
  il ne me reste plus qu'à vous dire au revoir et à bientôt pour un nouvel épisode de l'Humain à cœur du digital.
• 44:42
  Salut !
• 44:42
  A bientôt !
• 44:45
  Vous avez apprécié ce moment ?
• 44:46
  Alors laissez-nous un commentaire,
• 44:47
  un avis ou partagez cet épisode autour de vous.
• 44:51
  Et nous,
• 44:51
  on se dit à très bientôt pour un nouvel épisode de l'Humain à cœur du digital.