Page 158 - CATALOGUE AGINIUS 2020
P. 158

IT - Big Data - Cybersécurité                                                                                                                                IT - Big Data - Cybersécurité



                                                                                                                                                                                        Qualité logicielle et tests
                             JIRA                                           GIT et JENKINS                                                  ANSIBLE
                                                                                                                                                                                            Les fondamentaux
                                              1 jour                                               3 jours                                                     4 jours                                               4 jours
          Objectifs                          Ref. 4-IT-JIR     Objectifs                          Ref. 4-IT-GIJ            Objectifs                          Ref. 4-IT-ANS      Objectifs                         Ref. 4-IT-QBAS
       •  Prise en main des fonctionnalités de création de portails d’accès clients et   •  Comprendre les principes de l’intégration continue en vue de son   •  Comprendre en quoi Ansible se différencie des autres systèmes de gestion   •  Comprendre la problématique de la complexité des développements
        mise en place de bases de connaissances avec Jira Service Desk  implémentation                                   de configuration                                     logiciels
          Public                                           •  Intégrer Jenkins avec les autres outils (SCM, gestionnaire de tickets...)  •  Construire vos propres playbook  •  Comprendre le bénéfice de l’intégration continue pour améliorer la qualité
                                                                                                                                                                              des développements
                                                                                                                        •  Déployer dans le Cloud
                                                           •  Mettre en place un serveur Jenkins automatisant les build
       •  Futurs Consultants DevOps                        •  Automatiser les tests, les audits de code et les déploiements sur la   Public                                  •  Adopter les bonnes pratiques de rédaction des tests logiciels
                                                                                                                                                                             •  Mettre en place une stratégie de campagne de tests automatisés avec les
                                                             plateforme d’intégration Jenkins
                                                                                                                                                                              frameworks et outils du marché
          Prérequis                                        •  Présentation et utilisation de GIT                        •  Développeurs, architectes techniques, administrateurs et responsables   •  Travailler avec un gestionnaire de code source tel que Git, et adopter les
       •  Avoir des connaissances DevOps                       Public                                                    d’exploitation et de production                      réflexes du travail collaboratif
                                                                                                                           Prérequis
          Moyens pédagogiques                               •  Développeurs, chefs de projet                            •  Connaissances système Linux                       •  Comprendre le rôle des différents outils d’une chaîne d’intégration continue
                                                                                                                                                                             •  Utiliser un outil de construction logiciel pour automatiser les tâches de
                                                                                                                                                                              développement
      •  Alternance entre apports théoriques et exercices pratiques  Prérequis                                          •  Notions sur les réseaux TCP/IP                    •  Mettre en place une plateforme d’intégration continue autour de Jenkins
      •  Support de cours fourni lors de la formation       •  Connaissance du langage Java et notions du cycle de développement  •  Utilisation de la ligne de commande et du script Shell en environnement
                                                                                                                         Linux                                                   Public
                                                               Moyens pédagogiques                                         Moyens pédagogiques                               •  Développeurs, chefs de projets, architectes logiciels
                                                           •  Alternance entre apports théoriques et exercices pratiques  •  Alternance entre apports théoriques et exercices pratiques
                                                           •  Support de cours fourni lors de la formation              •  Support de cours fourni lors de la formation          Prérequis
                                                                                                                                                                             •  Posséder les connaissances et compétences équivalentes aux
                                                                                 Programme                                                                                     fondamentaux du développement Java ou aux fondamentaux du
                                                                                                                                                                               développement .NET ou aux fondamentaux de la programmation orientée
                                                                                                                                                                               objet en C++
                                                           1. Introduction à l’intégration continue
                            Programme                       •  Principes de l’intégration continue.                                          Programme                           Moyens pédagogiques
                                                            •  Développement agile et intégration continue.                                                                  •  Présentiel, présentiel à distance ou en format de blended learning
                                                            •  Prérequis à l’intégration continue.
      1. Introduction et revue des concepts                 •  Techniques de développement adaptées à l’intégration continue.  1. L’écosystème Ansible
       •  Rappel des fonctionnalités standards de Jira      •  Différents types de tests et d’audit d’une application.  •  Concept et présentation                                                Programme
       •  Rappel des principes ITIL                         •  Cycle de vie du processus de développement.              •  Ansible Galaxy
       •  Présentation du portail et de l’interface         •  Outils annexes et intégration.                           •  Présentation de Vagrant                           1. Introduction
       •  Agents, clients et contributeurs                 2. Mise en place et automatisation du Build                  •  Installation de l’environnement                   •  Pratiques d’ingénierie logicielle et méthodes Agiles.
      2. Travailler avec Jira Service Desk                  •  Mise en place du serveur, les différents types d’installation.  2. Création de playbook                       •  Le développement incrémental et itératif.
       •  Créer des demandes                                •  Configuration : page principale de la configuration, configuration de Git/  •  Conception d’un playbook       •  L’équipe Agile. Scrum et XP.
       •  Attacher des fichiers et des captures d’écran aux requêtes  SVN, serveur de mail.                             •  Fichier d’inventaire                              2. Les tests agiles
       •  Ajouter des participants à une demande            •  Jenkins et le Build, les meilleures pratiques et méthodes recommandées.  •  Variables et facts                •  Définition et périmètre des tests agiles.
       •  Modifier et collaborer sur des demandes           •  Stratégies et techniques de notification.                3. Mise en œuvre par l’exemple                       •  Cycle de développement : origine du TDD (Test Driven Development),
       •  Saisir du temps passé sur les demandes            •  Fixer les dépendances entre les travaux de Build.        •  Présentation de l’application d’exemple n-tiers     ATDD, TDR, les types de tests...
       •  Approuver une demande Service Desk                •  Jenkins et Maven : rappel sur Maven, configuration du Build Maven,   •  Les contraintes de la mise en production  3. Les tests développeurs
       •  Personnaliser les demandes d’un projet             déploiement dans un repository Maven.                      •  Déploiement avec Ansible                          •  Définition et objectifs : les patterns basiques XUnit.
       •  Chercher des demandes                            3. Qualité du code                                           4. Utilisation avancée                               •  Principe des tests unitaires automatisés.
       •  Utiliser et configurer les files d’attente        •  Introduction, intégration de la qualité dans le processus de build.                                           •  Règles de simplicité : règle des «3 A» (Arrange, Act, Assert).
       •  Créer une demande de la part d’un client          •  Outils d’analyse : Checkstyle, FindBugs, CPD/PMD.        •  Débogage                                          •  Mise en œuvre de tests unitaires avec JUnit, le framework de test en Java.
       •  Les workflows                                     •  Configuration du rapport qualité avec le plugin Violations.  •  Plugins                                       •  Lanceur de tests (TestRunner).
       •  Configuration des tableaux de bord                •  Rapport de complexité, sur les tâches ouvertes.          •  Ansible pour l’entreprise                         •  Les méthodes d’Assertions.
      3. Administrer les projets Jira Service Desk         4. Automatisation des tests                                  •  Déploiement dans le Cloud                         4. Le TDD, développement guidé par les tests
       •  Configuration par défaut des projets Jira Service Desk  •  Introduction, terminologie du test.                                                                     •  Le cycle de développement.
       •  Gérer l’accès à votre portail client              •  Automatisation des tests unitaires et d’intégration.                                                          •  Le principe du TDD : «test first», «tester, coder, refactorer».
       •  Configurer votre portail client                   •  Configuration des rapports.                                                                                   •  TDD et pratiques agiles (XP) : l’intégration continue, le Pair Programming.
       •  Recevoir des requêtes par mail                    •  Mesurer la couverture de test.                                                                                5. «Refactoring», le remaniement de code
       •  Configurer les types de requêtes                  •  Automatisation des tests d’acceptance.
       •  Configurer les notifications                      •  Automatisation des tests de performance avec JMeter.                                                          •  Principes du refactoring.
       •  Configurer les approbations                       •  Optimiser les temps d’exécution des tests.                                                                    •  Réduire l’apparition de la dette technique, rendre le code compréhensible.
       •  Automatiser votre service client                 5. Automatisation du déploiement                                                                                  •  Comment identifier le code à risque ? La notion de «Code Smells», signes
       •  Ajouter des clients et des organisations          •  Mise en place du script de déploiement.                                                                         de danger potentiel.
      4. Configurer les rapports                            •  Mise à jour des bases de données.                                                                             •  Les principales opérations de refactoring.
                                                                                                                                                                             •  Rappel sur les Design Patterns.
       •  Les types de rapport                              •  Tests minimaux. Retour en arrière.                                                                            6. Isolation des tests
       •  Créer des rapports personnalisés                 6. Administration d’un serveur Jenkins
       •  Mesurer la satisfaction client                    •  Activation de la sécurité et mise en place simple.                                                            •  Les doubles de test, leur utilisation.
       •  Vérifier la tenue de ses engagements              •  Différents types de bases utilisateurs.                                                                       •  Le «Mock Object» pour vérifier certaines hypothèses.
                                                            •  Gestion des autorisations et des rôles.                                                                       •  Le «Fake», pour la simulation.
                                                            •  Journalisation des actions utilisateur.                                                                       •  Le «Stub» : fournir une réponse prédéfinie à un appel.
                                                            •  Gestion de l’espace disque.                                                                                   7. Le test comme cahier des charges, la notion d’ATDD
                                                            •  Monitoring de la charge CPU.                                                                                  •  Les principes et avantages de l’ATDD.
                                                            •  Sauvegarde de la configuration.                                                                               •  Du scénario au test de recette.
                                                           7. Présentation de Git                                                                                            •  Combiner ATDD, BDD et TDD.
                                                            •  Concepts de base du contrôle de version.                                                                      •  Les outils (Fitnesse, Cucumber...).
                                                            •  La gestion centralisée ou distribuée.                                                                         8. Conclusions
                                                            •  Les différentes solutions de gestion de versions : (Git, CVS, SVN,                                            •  Les bénéfices du TDD, le coût des tests.
                                                             Mercurial, Bazaar...).                                                                                          •  Les autres types de tests (interface graphique, Web..).
                                                            •  Apports la décentralisation. Principe de fonctionnement.                                                      •  Quelques outils.
                                                           8. Configuration
                                                            •  Configuration du fichier gitconfig. La console.
                                                            •  Déclaration d’un outil d’analyse de différentiel de versions.
                                                           9. Utilisation de Git, les fondamentaux
                                                            •  Le modèle objet Git : blob, tree, commit et tag.
                                                            •  Le répertoire Git et le répertoire de travail.
                                                            •  L’index ou staging area.
                                                            •  Création et initialisation un dépôt.
                                                            •  Les concepts de branche, tag et de dépôt.
                                                            •  Outil de visualisation Gitk.
      156                                                                                  FORMATIONS 2020              FORMATIONS 2020                                                                                     157
   153   154   155   156   157   158   159   160   161   162   163