Tirer le meilleur parti de l’automatisation dans DevOps

Dans le contexte de DevOps, l’automatisation est essentielle pour rendre les processus évolutifs, cohérents et sécurisés. C’est pourquoi les équipes DevOps doivent constamment être à la recherche de solutions pour automatiser les flux de travail et rendre les automatisations qu’elles utilisent déjà encore plus efficaces.

Ci-dessous, nous expliquons le rôle que joue l’automatisation dans DevOps, ce que l’automatisation apporte à DevOps, des exemples d’automatisation DevOps et les meilleures pratiques pour démarrer avec l’automatisation des processus DevOps.

Qu’est-ce que l'automatisation DevOps ?

L’automatisation DevOps est l’utilisation d’outils pour automatiser tout type de flux de travail ou de processus qu’une équipe DevOps doit effectuer. En d’autres termes, lorsque vous prenez un processus DevOps – tel que le test ou le déploiement de logiciels – et que vous utilisez un outil pour automatiser le processus en partie ou en totalité, vous utilisez l’automatisation DevOps.

Exemples d’automatisation DevOps

Pour contextualiser ce que l’automatisation DevOps signifie dans la pratique, examinons quelques exemples courants de flux de travail DevOps qui peuvent être automatisés. Cette liste n’est pas exhaustive ; en effet, pratiquement tous les processus effectués par les membres de l’équipe DevOps ont le potentiel d’être automatisés. Cependant, les processus décrits ci-dessous font partie des flux de travail DevOps les plus courants et les plus importants. Ce sont donc de bons points de départ pour les organisations qui cherchent à se lancer dans l’automatisation DevOps.

Provisionnement de l’infrastructure

Le provisionnement d’infrastructure est le processus de configuration de l’infrastructure qui héberge les charges de travail DevOps. Par exemple, si vous exécutez des charges de travail sur des instances de machine virtuelle basées sur le cloud, le processus de provisionnement implique de décider quels types d’instances utiliser, puis de les configurer avec le système d’exploitation, les packages, les bibliothèques, etc. souhaités.

Vous pouvez effectuer ce processus manuellement. Les ingénieurs peuvent lancer chaque instance de machine virtuelle manuellement, puis la configurer selon les besoins. Mais une approche plus efficace et évolutive consisterait à appliquer l’automatisation DevOps au provisionnement de l’infrastructure.

Vous pouvez le faire à l’aide d’outils Infrastructure-as-Code (IaC), tels que like Terraform. Les outils IaC permettent aux équipes DevOps de définir des configurations pour l’infrastructure, puis d’appliquer ces configurations automatiquement dans leurs environnements. Par exemple, vous pouvez utiliser CloudFormation, l’outil IaC intégré au cloud AWS, pour configurer automatiquement les instances de machines virtuelles AWS EC2 en fonction du code IaC comme suit (il fait partie d’un modèle qui configure les paramètres IP et de port) :

"Resources" : {

    "EC2Instance" : {

      "Type" : "AWS::EC2::Instance",

      "Properties" : {

        "UserData" : { "Fn::Base64" : { "Fn::Join" : [ "", [ "IPAddress=", {"Ref" : "IPAddress"}]]}},

        "InstanceType" : { "Ref" : "InstanceType" },

        "SecurityGroups" : [ { "Ref" : "InstanceSecurityGroup" } ],

        "KeyName" : { "Ref" : "KeyName" },

        "ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" },

                          { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ]

} ] }

      }

    },

 

    "InstanceSecurityGroup" : {

      "Type" : "AWS::EC2::SecurityGroup",

      "Properties" : {

        "GroupDescription" : "Enable SSH access",

        "SecurityGroupIngress" : 

          [ { "IpProtocol" : "tcp", "FromPort" : "22", "ToPort" : "22", "CidrIp" : { "Ref" : "SSHLocation"} }]

      }

    },

 

    "IPAddress" : {

      "Type" : "AWS::EC2::EIP"

    },

 

    "IPAssoc" : {

      "Type" : "AWS::EC2::EIPAssociation",

      "Properties" : {

        "InstanceId" : { "Ref" : "EC2Instance" },

        "EIP" : { "Ref" : "IPAddress" }

      }

    }

  }

 

En utilisant cette approche, vous évitez d’avoir à vous connecter à chaque instance de machine virtuelle et à configurer ses paramètres réseau manuellement.

Tests logiciels

Les tests logiciels sont le processus d’évaluation d’un logiciel pour déterminer s’il répond aux exigences de convivialité, de performance, de sécurité et autres. Les équipes DevOps exécutent généralement des tests logiciels après avoir créé une nouvelle version de l’application, mais avant de la déployer en production. Si l’application réussit les tests nécessaires, elle est déployée ; sinon, les bugs sont corrigés et elle est reconstruite et testée.

Les équipes DevOps peuvent effectuer des tests logiciels manuellement en évaluant manuellement chaque version de l’application. Mais une approche beaucoup plus efficace consiste à automatiser les tests logiciels à l’aide d’un cadre de test automatisé. Les frameworks de test automatisés permettent aux ingénieurs d’écrire des scripts qui définissent les aspects d’une application à tester. Ensuite, les scripts peuvent être exécutés automatiquement et les résultats peuvent être évalués pour déterminer si l’application répond aux exigences nécessaires pour être déployée.

Il existe une variété de frameworks d’automatisation des tests disponibles. Ils varient en ce qui concerne les langages de programmation qu’ils prennent en charge et les types de tests qu’ils peuvent exécuter. Cependant, si vous débutez avec l’automatisation des tests logiciels DevOps, un bon cadre à considérer est Selenium, qui est open source et prend en charge une variété de cas d’utilisation de test.

Avec Selenium, vous pouvez écrire un test comme le suivant pour évaluer votre application automatiquement :

À partir de Selenium Import Webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.chrome.service import Service as ChromeService

from webdriver_manager.chrome import ChromeDriverManager

 

def test_eight_components():

driver = webdriver.Chrome(service=ChromeService(executable_path=ChromeDriverManager().install()))

driver.get("https://www.selenium.dev/selenium/web/web-form.html")

 

title = driver.title

assert title == "Web form"

 

driver.implicitly_wait(0.5)

 

text_box = driver.find_element(by=By.NAME, value="my-text")

submit_button = driver.find_element(by=By.CSS_SELECTOR, value="button")

 

text_box.send_keys("Selenium")

submit_button.click()

 

message = driver.find_element(by=By.ID, value="message")

value = message.text

assert value == "Received!"

 

driver.quit()

 

Comme vous pouvez le voir, ce test est un script Python qui importe le package webdriver. Webdriver est un outil qui exécute des interactions scriptées avec un navigateur Web, ce qui en fait un script utile pour les équipes DevOps qui souhaitent tester automatiquement les applications Web.

CI/CD

Les processus nécessaires pour déplacer les logiciels vers le bas du pipeline CI/CD, tels que l’envoi du code source dans les outils de construction ou le début des processus d’automatisation des tests, peuvent être exécutés à l’aide de l’automatisation du pipeline DevOps.

Par exemple, voici un fichier de configuration simple pour JFrog Pipelines, un outil d’automatisation CI/CD, qui définit une série d’étapes de pipeline (nommées p1_s1, p1_s2 et ainsi de suite dans l’exemple) à effectuer dans un pipeline CI/CD :

pipelines:

  – name: my_first_pipeline

steps:

– name: p1_s1

type : Bash

configuration:

inputResources:

# Sets up step to be triggered when there are commit events to myFirstRepo

– name: myFirstRepo

execution:

onExecute:

# Les données des ressources d’entrée sont disponibles sous forme de variables env à l’étape

– echo $res_myFirstRepo_commitSha

# Les deux commandes suivantes ajoutent des variables à l’état d’exécution, qui est disponible pour toutes les étapes en aval de cette exécution

# Documentation de l’état d’exécution : https://www.jfrog.com/fr/confluence/display/JFROG/Creating+Stateful+Pipelines#CreatingStatefulPipelines-RunState

– add_run_variables current_runid=$run_id

– add_run_variables commitSha=$res_myFirstRepo_commitSha

# Cette variable est écrite dans l’état du pipeline dans p1_s3.

# Elle sera donc vide lors de la première exécution et sera définie sur le numéro d’exécution précédent lors des exécutions suivantes

# Documentation sur l’état du pipeline : https://www.jfrog.com/fr/confluence/display/JFROG/Creating+Stateful+Pipelines#CreatingStatefulPipelines-PipelineState

– echo "Previous run ID is $prev_runid"

 

– name: p1_s2

type : Bash

configuration:

inputSteps :

– name: p1_s1

execution:

onExecute:

# Démontre la disponibilité d’une variable env écrite pour l’état d’exécution pendant p1_s1

– echo $current_runid

 

– name: p1_s3

type : Bash

configuration:

inputSteps :

– name: p1_s2

outputResources:

– name: myPropertyBag

execution:

onExecute:

– echo $current_runid

# Écrit le numéro d’exécution actuel vers l’état du pipeline

– add_pipeline_variables prev_runid=$run_id

# Utilise une fonction utilitaire pour mettre à jour la ressource de sortie avec le commitSha qui a déclenché cette exécution

# Les pipelines dépendants peuvent être configurés pour se déclencher lors de la mise à jour de cette ressource

# Documentation des fonctions utilitaires : https://www.jfrog.com/fr/confluence/display/JFROG/Pipelines+Utility+Functions

– write_output myPropertyBag commitSha=$commitSha runID=$current_runid

 

En exécutant une série d’étapes comme celles-ci à l’aide d’un outil tel que JFrog Pipelines, les équipes DevOps peuvent automatiser des processus qu’elles devraient autrement exécuter manuellement, créant ainsi un potentiel d’inefficacité et de retards.

Les avantages de l’automatisation DevOps

DevOps fait référence à une stratégie de livraison de logiciels qui intègre le développement et les opérations informatiques.

Bien qu’il soit possible de fournir une approche DevOps sans automatisation, il est difficile d’exécuter des processus DevOps efficacement ou de manière cohérente sans son aide. Ce n’est que grâce à l’automatisation que les équipes DevOps peuvent obtenir des avantages tels que :

• La capacité d’accomplir plus avec moins de membres de l’équipe DevOps.
• La réduction de la quantité de « labeur » – c’est-à-dire les tâches manuelles fastidieuses – que les ingénieurs DevOps doivent effectuer.
• La réalisation de processus cohérents et reproductibles de manière fiable (car les outils d’automatisation donneront toujours le même rendement tant qu’ils sont configurés de la même manière).
• La capacité de maintenir la cohérence des processus, peu importe qui les exécute.
• Réduction du risque que le départ ou la promotion d’un membre du personnel perturbe les opérations DevOps parce que personne d’autre ne sait comment effectuer le travail de cette personne. Lorsque DevOps est automatisé, les processus peuvent se poursuivre, quels que soient les ingénieurs de l’équipe.

Outils d'automatisation DevOps

D’une manière générale, les outils d’automatisation DevOps se divisent en deux catégories principales.

La première consiste en des outils conçus pour automatiser un type particulier de processus DevOps, mais pas l’ensemble de l’opération de livraison de logiciels DevOps. Par exemple, vous pouvez utiliser un outil IaC comme Terraform pour automatiser le provisionnement de l’infrastructure, ou un framework d’automatisation des tests pour exécuter des tests logiciels automatisés. Mais comme chacun de ces outils répond à un besoin spécifique et restreint, vous devez déployer plusieurs outils pour automatiser la plupart ou tous les aspects de DevOps.

L’autre catégorie d’outils DevOps se compose de plates-formes DevOps conçues pour permettre l’automatisation DevOps de bout en bout, ou quelque chose de proche. Une plate-forme DevOps comprend des outils pour automatiser tous les processus et flux de travail DevOps de base, tels que l’automatisation CI/CD, l’analyse de sécurité, la livraison de logiciels et la gestion des artefacts. Une plate-forme DevOps peut également relier les outils et processus supplémentaires qui existent dans votre chaîne d’approvisionnement pour aider des outils d’automatisation disparates à fonctionner ensemble de manière transparente.

Meilleures pratiques pour automatiser DevOps

Chaque organisation est différente et il n’existe pas d’approche universelle de l’automatisation DevOps. Mais en général, les meilleures pratiques de base pour tirer le meilleur parti de l’automatisation DevOps sont les suivantes :

• Commencez par des fruits à portée de main : Démarrez avec l’automatisation DevOps en identifiant les processus les plus faciles à automatiser et développez à partir de là en automatisant des processus supplémentaires. Ceci est important car il ne faut pas perdre le support ou l’adhésion à une initiative d’automatisation DevOps en mordant plus que vous ne pouvez mâcher au début.
• Envisagez une automatisation partielle : L’automatisation DevOps n’a pas besoin d’être totale. Dans les cas où il est trop difficile d’automatiser complètement un processus, vous pouvez l’automatiser partiellement. Par exemple, vous pouvez utiliser l’automatisation du pipeline pour préparer le code afin de descendre automatiquement dans le pipeline, tout en demandant à un ingénieur d’approuver manuellement les modifications avant leur implémentation. De cette façon, vous obtenez l’efficacité de l’automatisation ainsi que l’assurance d’avoir la supervision d’un humain.
• Améliorer continuellement : L’automatisation ne devrait pas être une opération que l'on fait une fois pour toutes. En plus de rechercher des processus manuels que vous pouvez automatiser, cherchez des moyens d’augmenter l’efficacité ou l’évolutivité des automatisations que vous avez déjà en place, afin d’en tirer encore plus de valeur. Par exemple, si vous automatisez certains de vos tests logiciels aujourd’hui, réfléchissez à la façon dont vous pouvez automatiser encore plus.
• Suivre les métriques d’automatisation : Assurez-vous de pouvoir quantifier la valeur créée par l’automatisation DevOps – et de trouver les situations où elle est insuffisante – en suivant les métriques liées à l’automatisation. Un bon point de départ ici sont les métriques DORA souvent citées : Fréquence de déploiement, délai de changement, délai de récupération et taux d’échec des changements. Vous pouvez également suivre le temps nécessaire pour déployer une application automatiquement au lieu de le faire manuellement, ou évaluer dans quelle mesure vous réduisez le temps nécessaire pour rechercher et corriger un bogue lorsque vous utilisez des tests automatisés au lieu de tests manuels.

La mise en œuvre des automatisations DevOps peut prendre du temps et le gain peut ne pas être immédiatement évident. Ce n’est que lorsque votre équipe a travaillé sur de nombreux cycles de publication de logiciels et que les ingénieurs ont une idée du temps qu’ils gagnent en minimisant les processus manuels que tous les avantages de l’automatisation DevOps commencent à apparaître clairement. Pour cette raison, il est important de ne pas rejeter les initiatives d’automatisation comme un échec simplement parce qu’elles ne semblent pas apporter de changement transformateur du jour au lendemain.