DifficileChoix unique

Question d'entraînement AZ-400

Une entreprise utilise Azure Pipelines pour compiler une application .NET Core. La compilation prend 45 minutes en raison de la restauration des dépendances. Elle souhaite réduire le temps de compilation. Quelle est la stratégie la plus efficace ?

Choisissez la meilleure réponse.

Bonne réponse

  • AMettre en cache les packages NuGet et activer la mise en cache dans le pipeline

Explication

Mettre en cache les packages NuGet dans Azure Pipelines est la stratégie la plus efficace car la restauration des dépendances est le principal goulet d'étranglement, téléchargeant souvent des centaines de packages depuis nuget.org. En mettant en cache le dossier ~/.nuget/packages, les compilations suivantes ignorent entièrement le téléchargement réseau, réduisant ainsi le temps de compilation de 45 minutes à quelques minutes. Cela résout directement la cause profonde, à savoir la restauration répétitive des packages, sans nécessiter d'infrastructure supplémentaire ou de parallélisme.

Pourquoi chaque option est juste ou fausse

A

Juste

Mettre en cache les packages NuGet et activer la mise en cache dans le pipeline

La tâche `DotNetCoreCLI`/`NuGetCommand` avec mise en cache utilise une clé de cache dérivée du fichier NuGet.config et des fichiers de projet (ou de packages.lock.json), et stocke le dossier des packages globaux (`~/.nuget/packages`) sur le serveur Azure DevOps. En cas de correspondance dans le cache, `dotnet restore` peut satisfaire les références de packages à partir du cache local plutôt de les télécharger, réduisant le temps de restauration de dizaines de secondes à presque zéro. Le cache est restauré dans l'espace de travail de l'agent au démarrage du travail, il fonctionne donc d'une exécution de pipeline à l'autre, même sur des agents hébergés qui sont éphémères. Cela résout directement le goulet d'étranglement réseau qui provoquait la lenteur des compilations.

B

Fausse

Utiliser des tâches parallèles dans le pipeline

Les tâches parallèles (ou les exécutions de pipelines parallèles) distribuent des éléments indépendants sur plusieurs agents pour s'exécuter simultanément ; elles peuvent améliorer le débit lorsqu'il y a de nombreuses tâches indépendantes, mais elles n'accélèrent pas l'exécution d'une seule compilation linéaire. Dans une compilation .NET Core typique, les étapes (restauration, compilation, test, publication) sont séquentielles et dépendantes les unes des autres ; les diviser en tâches parallèles nécessiterait soit une orchestration complexe multi-tâches, soit un travail dupliqué, et l'étape de restauration téléchargerait toujours les mêmes packages depuis NuGet sur chaque agent. Par conséquent, le temps total d'exécution pour un seul pipeline reste dominé par la même restauration de packages limitée par le réseau.

C

Fausse

Utiliser un agent auto-hébergé avec plus de CPU

Un agent auto-hébergé doté de cœurs de CPU supplémentaires accélère les étapes gourmandes en processeur comme la compilation et l'empaquetage, mais le temps de compilation observé est dominé par la latence réseau et la bande passante lors du téléchargement des packages NuGet à partir de flux externes. La mise à niveau du CPU n'augmente pas le débit réseau ni n'élimine le besoin de récupérer les packages ; l'étape de restauration attendra toujours la même E/S réseau. Même avec un processeur plus rapide, la phase de restauration de MSBuild est limitée par les E/S, et la compilation représente une fraction comparativement faible une fois que les packages sont disponibles. Par conséquent, cette option ne réduirait pas de manière significative la durée totale de la compilation.

D

Fausse

Activer les compilations incrémentielles

Les compilations incrémentielles (via les vérifications de mise à jour de MSBuild ou en spécifiant `--no-restore` après une restauration précédente) évitent de recompiler les projets inchangés, mais l'étape lente du pipeline est le `dotnet restore` qui résout et télécharge les packages NuGet depuis le réseau. Même si la compilation est entièrement ignorée, l'étape de restauration doit toujours interroger la source du package et télécharger les fichiers .nupkg à partir de zéro sur chaque nouvel agent ou lorsque le cache n'existe pas ; la compilation incrémentielle ne fait rien pour éviter cette récupération réseau. Les packages sont généralement les mêmes à chaque fois, de sorte qu'une compilation incrémentielle ne peut pas réduire le temps passé à attendre l'acquisition des packages.

Pour aller plus loin

La cause profonde ici est que `dotnet restore` effectue un aller-retour réseau vers NuGet.org (ou un flux interne) pour résoudre et télécharger chaque référence de package, et cette latence de téléchargement dépasse généralement le temps de compilation. Un cache de pipeline, implémenté avec la tâche `Cache` ou l'option de mise en cache intégrée `NuGetCommand`, stocke les fichiers de packages extraits (dossier des packages globaux) sur le serveur Azure DevOps et les restaure dans l'espace de travail de l'agent avant l'exécution des étapes de compilation. La clé de cache doit refléter les entrées réelles, généralement un hachage de project.assets.json ou des fichiers de projet eux-mêmes, de sorte que les mises à jour de packages invalident le cache. Une idée reçue fréquente est que les tâches parallèles ou un agent plus puissant sont la solution ; en réalité, les deux paient toujours le coût total de la restauration réseau par agent, alors que la mise en cache l'élimine pour les dépendances inchangées.

À propos de ces questions d'entraînement

Cette question fait partie des questions d'entraînement AZ-400 originales de Courseiva, rédigées pour apprendre et jamais copiées d'examens réels ou de dumps.

Traduite de l'original anglais avec l'IA et vérifiée pour le sens. Les codes d'examen, les commandes et les noms de produits sont conservés tels qu'ils apparaissent à l'examen.