DifícilMúltipla escolha

Questão de prática de AZ-400

Uma empresa usa o Azure Pipelines para compilar um aplicativo .NET Core. A compilação leva 45 minutos devido à restauração de dependências. Eles querem reduzir o tempo de compilação. Qual é a estratégia mais eficaz?

Escolha a melhor resposta.

Resposta correta

  • AArmazenar em cache os pacotes NuGet e habilitar o cache no pipeline

Explicação

O armazenamento em cache dos pacotes NuGet no Azure Pipelines é a estratégia mais eficaz porque a restauração de dependências é o principal gargalo, baixando frequentemente centenas de pacotes do nuget.org. Ao armazenar em cache a pasta ~/.nuget/packages, as compilações subsequentes ignoram totalmente o download de rede, reduzindo o tempo de compilação de 45 minutos para poucos minutos. Isso aborda diretamente a causa raiz — a restauração repetitiva de pacotes — sem exigir infraestrutura adicional ou paralelismo.

Por que cada alternativa está certa ou errada

A

Correta

Armazenar em cache os pacotes NuGet e habilitar o cache no pipeline

A tarefa `DotNetCoreCLI`/`NuGetCommand` com cache usa uma chave de cache derivada do NuGet.config e dos arquivos do projeto (ou packages.lock.json), e armazena a pasta de pacotes globais (`~/.nuget/packages`) no servidor do Azure DevOps. Em caso de acerto de cache, o `dotnet restore` pode atender às referências de pacotes a partir do cache local em vez de baixá-las, cortando o tempo de restauração dezenas de segundos para quase zero. O cache é restaurado no espaço de trabalho do agente na inicialização do trabalho, funcionando assim em execuções de pipeline mesmo em agentes hospedados, que são efêmeros. Isso aborda diretamente o gargalo de rede que causava a lentidão nas compilações.

B

Incorreta

Usar trabalhos paralelos no pipeline

Trabalhos paralelos (ou execuções de pipeline paralelas) distribuem partes independentes entre vários agentes para rodar simultaneamente; eles podem melhorar a taxa de transferência quando há muitos trabalhos independentes, mas não aceleram a execução de uma única compilação linear. Em uma compilação típica de .NET Core, as etapas (restaurar, compilar, testar, publicar) são sequenciais e dependem umas das outras; dividi-las em trabalhos paralelos exigiria uma orquestração complexa de múltiplos trabalhos ou duplicaria o trabalho, e a etapa de restauração ainda baixaria os mesmos pacotes do NuGet em cada agente. Consequentemente, o tempo de relógio de parede para uma única execução de pipeline continua dominado pela mesma restauração de pacotes vinculada à rede.

C

Incorreta

Usar um agente hospedado por conta própria com mais CPU

Um agente hospedado por conta própria com núcleos de CPU adicionais acelera etapas vinculadas à CPU, como compilação e empacotamento, mas o tempo de compilação observado é dominado pela latência de rede e largura de banda ao baixar pacotes NuGet de feeds externos. Atualizar a CPU não aumenta a taxa de transferência da rede nem elimina a necessidade de buscar pacotes; a etapa de restauração ainda aguardará na mesma E/S de rede. Mesmo com um processador mais rápido, a fase de restauração do MSBuild é limitada por E/S, e a compilação representa uma fração comparativamente pequena assim que os pacotes estão disponíveis. Portanto, esta opção não reduziria significativamente a duração total da compilação.

D

Incorreta

Habilitar compilações incrementais

As compilações incrementais (por meio de verificações de atualidade do MSBuild ou especificando `--no-restore` após uma restauração anterior) evitam recompilar projetos inalterados, mas a etapa lenta do pipeline é o `dotnet restore`, que resolve e baixa pacotes NuGet da rede. Mesmo que a compilação seja ignorada inteiramente, a etapa de restauração ainda deve consultar a origem do pacote e baixar os arquivos .nupkg do zero em cada novo agente ou quando o cache não existir; a compilação incremental não faz nada para evitar essa busca pela rede. Os pacotes são tipicamente os mesmos a cada vez, de modo que uma compilação incremental não pode reduzir o tempo gasto aguardando a aquisição de pacotes.

Para se aprofundar

A causa raiz aqui é que o `dotnet restore` realiza uma viagem de ida e volta de rede para o NuGet.org (ou um feed interno) para resolver e baixar cada referência de pacote, e essa latência de download normalmente excede o tempo de compilação. Um cache de pipeline, implementado com a tarefa `Cache` ou com a opção integrada de cache do `NuGetCommand`, armazena os arquivos de pacotes extraídos (pasta de pacotes globais) no servidor do Azure DevOps e os restaura no espaço de trabalho do agente antes que as etapas de compilação sejam executadas. A chave de cache deve refletir as entradas reais — geralmente um hash do project.assets.json ou dos próprios arquivos do projeto — para que as atualizações de pacotes invalidem o cache. Um equívoco comum é achar que trabalhos paralelos ou um agente mais potente são a resposta; na realidade, ambos ainda pagam o custo total de restauração de rede por agente, enquanto o cache o elimina para dependências inalteradas.

Sobre estas questões de prática

Esta é uma das questões de prática originais de AZ-400 da Courseiva, escrita para o aprendizado e nunca copiada de provas reais nem de dumps.

Traduzida do original em inglês com IA e conferida quanto ao sentido. Códigos de exame, comandos e nomes de produtos são mantidos como aparecem na prova.