![](https://www.ambient-it.net/wp-content/uploads/2024/08/azure-avec-lIA.webp)
L’IA s’est solidement implantée dans le paysage du développement logiciel, et pour les professionnels DevOps, cela signifie repenser les pipelines traditionnels. Azure DevOps, en tant qu’orchestrateur CI/CD, offre une plateforme robuste pour automatiser et optimiser les workflows de développement, et l’intégration de l’IA ouvre de nouveaux horizons en termes de performances et d’efficacité.
Avant de se lancer
Vous souhaitez maitriser Azure et tous ses secrets ? Notre formation Azure Devops Service vous permettra de gérer et à rationaliser le développement et la livraison de projets logiciels complexes.
L’équipe Ambient IT
Qu’est-ce que l’IA dans Azure DevOps ?
L’ajout de processus d’IA dans vos tâches azure Devops est en réalité l’ensemble des outils qui visent à automatiser, prédire et améliorer les tâches de développement et de déploiement.
L’IA peut, par exemple, automatiser les tests, optimiser les builds, analyser le code pour la qualité et la sécurité, et gérer les déploiements intelligents.
Pourquoi intégrer l’IA dans votre pipeline Azure ?
C’est une solution cruciale pour accélérer le cycle de vie du développement logiciel, mais aussi très utile pour réduire les erreurs humaines et d’améliorer la qualité des applications.
Vous pouvez aussi, grâce à l’IA prédire des failles de sécurité, optimiser des ressources et analyser en temps réel des performances des applications.
Services Azure et Intégration de l’IA
Azure propose nativement de nombreux services et outils spécifiques parmi lesquels on peut citer :
- Azure Machine Learning
- Azure Cognitive Services
- AKS
ils facilitent l’intégration de l’IA dans les pipelines DevOps. Ces services permettent de construire, entraîner et déployer des modèles d’IA directement dans le flux de travail du CI/CD.
Comment intégrer Azure Machine Learning dans un pipeline DevOps ?
Pour intégrer Azure Machine Learning dans un pipeline DevOps, assurez-vous d’avoir :
- Un compte et un projet Azure DevOps
- Un espace de travail Azure ML
- Un référentiel contenant vos scripts ML et le fichier YAML du pipeline
Vous pouvez ensuite créer une configuration de pipeline YAML comme dans cet exemple :
# azure-pipelines.yml
trigger:
branches:
include:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
azureSubscription: '<YOUR_AZURE_SUBSCRIPTION>'
resourceGroup: '<YOUR_RESOURCE_GROUP>'
workspaceName: '<YOUR_WORKSPACE_NAME>'
location: '<YOUR_LOCATION>'
computeName: '<YOUR_COMPUTE_NAME>'
environmentName: '<YOUR_ENVIRONMENT_NAME>'
modelName: '<YOUR_MODEL_NAME>'
trainScript: 'train.py'
steps:
- task: UsePythonVersion@0
inputs:
versionSpec: '3.x'
addToPath: true
- script: |
python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt
displayName: 'Set up Python environment and install dependencies'
- task: AzureCLI@2
inputs:
azureSubscription: $(azureSubscription)
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: |
az extension add -n azure-cli-ml
az ml workspace create -g $(resourceGroup) -w $(workspaceName) -l $(location)
az ml compute create -n $(computeName) --type AmlCompute --size STANDARD_D2_V2 --min-nodes 0 --max-nodes 4 -w $(workspaceName) -g $(resourceGroup)
- task: AzureCLI@2
inputs:
azureSubscription: $(azureSubscription)
scriptType: 'bash'
scriptLocation: 'inlineScript'
inlineScript: |
az ml environment create -n $(environmentName) -g $(resourceGroup) -w $(workspaceName) --image mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:20230126.v1 --conda-file environment.yml
- script: |
source venv/bin/activate
python run_train.py --subscription_id $(azureSubscription) --resource_group $(resourceGroup) --workspace_name $(workspaceName) --compute_name $(computeName) --environment_name $(environmentName) --model_name $(modelName) --train_script $(trainScript)
displayName: 'Run training on Azure ML'
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: 'outputs'
ArtifactName: 'model'
displayName: 'Publish trained model'
Puis, il vous faut créer votre script de formation (run_train.py
) :
from azureml.core import Workspace, Experiment, ScriptRunConfig, Environment
from azureml.core.compute import ComputeTarget, AmlCompute
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--subscription_id', type=str, help='Azure subscription ID')
parser.add_argument('--resource_group', type=str, help='Azure resource group')
parser.add_argument('--workspace_name', type=str, help='Azure ML workspace name')
parser.add_argument('--compute_name', type=str, help='Azure ML compute name')
parser.add_argument('--environment_name', type=str, help='Azure ML environment name')
parser.add_argument('--model_name', type=str, help='Model name to register')
parser.add_argument('--train_script', type=str, help='Training script file name')
args = parser.parse_args()
# Get the Azure ML workspace
ws = Workspace(subscription_id=args.subscription_id, resource_group=args.resource_group, workspace_name=args.workspace_name)
# Get the compute target
compute_target = ComputeTarget(workspace=ws, name=args.compute_name)
# Define the environment
environment = Environment.get(workspace=ws, name=args.environment_name)
# Define the script run configuration
src = ScriptRunConfig(source_directory='.', script=args.train_script, compute_target=compute_target, environment=environment)
# Create and run the experiment
experiment = Experiment(workspace=ws, name='training-experiment')
run = experiment.submit(src)
run.wait_for_completion(show_output=True)
# Register the model
run.register_model(model_name=args.model_name, model_path='outputs/model')
Ainsi que votre fichier environnement :
name: project_environment
dependencies:
- python=3.8
- pip:
- azureml-core
- azureml-sdk
- scikit-learn
- pandas
En suivant ces étapes, vous pouvez donc intégrer Azure Machine Learning dans votre pipeline Azure DevOps, ce qui vous permettra d’automatiser la formation et le déploiement de vos applications.
Gestion du Cycle de Vie de l’IA
Avec L’IA, vous pourrez ainsi automatiser la gestion du versionning. Vous pouvez entrainer vos modèles comme ceci :
from azureml.core import Workspace, Experiment, ScriptRunConfig, Environment, Model
from azureml.core.compute import ComputeTarget
import argparse
import os
parser = argparse.ArgumentParser()
parser.add_argument('--subscription_id', type=str, help='Azure subscription ID')
parser.add_argument('--resource_group', type=str, help='Azure resource group')
parser.add_argument('--workspace_name', type=str, help='Azure ML workspace name')
parser.add_argument('--compute_name', type=str, help='Azure ML compute name')
parser.add_argument('--environment_name', type=str, help='Azure ML environment name')
parser.add_argument('--model_name', type=str, help='Model name to register')
parser.add_argument('--train_script', type=str, help='Training script file name')
parser.add_argument('--model_path', type=str, help='Path to save the trained model')
args = parser.parse_args()
# Get the Azure ML workspace
ws = Workspace(subscription_id=args.subscription_id, resource_group=args.resource_group, workspace_name=args.workspace_name)
# Get the compute target
compute_target = ComputeTarget(workspace=ws, name=args.compute_name)
# Define the environment
environment = Environment.get(workspace=ws, name=args.environment_name)
# Define the script run configuration
src = ScriptRunConfig(source_directory='.', script=args.train_script, compute_target=compute_target, environment=environment)
# Create and run the experiment
experiment = Experiment(workspace=ws, name='training-experiment')
run = experiment.submit(src)
run.wait_for_completion(show_output=True)
# Register the model with versioning
model = run.register_model(model_name=args.model_name, model_path=args.model_path)
print(f'Model registered: {model.name}, Version: {model.version}')
Les pratiques recommandées incluent pour l’automatisation du versionning sont :
- l’adoption de conventions de nommage cohérentes
- l’utilisation de l’approche Semantic Versioning pour les modèles
- l’intégration de tests automatisés pour valider les changements avant le déploiement
Tests Intelligents
L’automatisation des tests avec l’IA peut se faire par la génération de cas de test basés sur des données précédentes.
Vous pouvez utiliser des scipts de test comme ceci :
import pytest
from model import ModelClass # Replace with your actual model import
def test_model_output():
model = ModelClass()
input_data = [...] # Replace with actual input data
expected_output = [...] # Replace with expected output
assert model.predict(input_data) == expected_output
Quelles sont les meilleures pratiques pour tester et valider des modèles d’IA?
Les meilleures pratiques comprennent :
- Validation croisée des modèles pour garantir leur généralisation
- Tests de performance pour évaluer le temps de réponse et la consommation de ressources
- Tests de sécurité pour détecter les vulnérabilités potentielles
Conclusion
L’avenir des pipelines Azure avec l’IA est prometteur, avec des améliorations continues dans l’automatisation, la prédiction et l’optimisation des processus de développement et de déploiement.
Si vous souhaitez débuter avec l’IA dans azure, familiarisez-vous d’abord avec les services Azure d’IA, intégrez des tâches d’IA simples dans votre pipeline actuel et évoluez progressivement vers des workflows plus complexes et automatisés.
En intégrant l’IA dans vos pipelines Azure, vous pouvez non seulement optimiser vos processus DevOps mais également positionner votre entreprise à l’avant-garde de l’innovation technologique.
Ressources supplémentaires pour approfondir l’IA dans Azure DevOps
- Microsoft Learn
- Documentation officielle Azure Machine Learning
- GitHub pour les exemples de code et les templates