FácilMúltipla escolha

Questão de prática de AZ-400

Sua equipe gerencia um monorepo grande no Azure Repos contendo vários projetos. Os desenvolvedores reclamam frequentemente que clonar todo o repositório demora muito e que eles precisam apenas de um subconjunto do código. A equipe usa o Git LFS para arquivos binários grandes. O repositório atualmente possui 50.000 commits e tem 5 GB de tamanho. Você deseja melhorar o desempenho da clonagem sem sacrificar a capacidade de contribuir para qualquer parte do repositório. O que você deve fazer?

Escolha a melhor resposta.

Resposta correta

  • BInstrua os desenvolvedores a usarem um clone superficial com profundidade 1 para reduzir o tempo de clonagem.

Explicação

O uso de um clone superficial com depth 1 reduz significativamente o tempo de clonagem ao buscar apenas o histórico de commits mais recente em vez de todos os 50.000 commits. Isso minimiza os dados transferidos pela rede, que é a principal causa de clonagens lentas. Os desenvolvedores podem aprofundar o clone posteriormente se precisarem de mais histórico. O sparse checkout sozinho não reduz os dados transferidos durante a clonagem; ele apenas limita o que aparece no diretório de trabalho. O Git LFS já está sendo usado para binários grandes, então esse não é o problema. Dividir o monorepo exigiria uma reestruturação significativa e pode complicar as contribuições entre projetos.

Por que cada alternativa está certa ou errada

A

Incorreta

Configure o sparse checkout para que os desenvolvedores possam clonar apenas os diretórios de que precisam.

O sparse checkout configura o Git para extrair apenas um subconjunto de arquivos na árvore de trabalho, mas durante a operação de clonagem, o Git ainda baixa todo o banco de dados de objetos, incluindo todos os blobs e árvores para cada commit, porque o índice e o armazenamento de objetos não são filtrados. O tamanho da transferência do clone permanece inalterado; o sparse checkout apenas economiza espaço em disco local e reduz o tempo necessário para popular o diretório de trabalho. Portanto, ele não faz nada para melhorar o tempo de clonagem limitado pela rede.

B

Correta

Instrua os desenvolvedores a usarem um clone superficial com profundidade 1 para reduzir o tempo de clonagem.

Um clone superficial com `depth 1` recupera apenas o commit mais recente de cada branch, omitindo todo o histórico de commits e todos os objetos históricos de árvore e blob que não são alcançáveis a partir dessa ponta. Isso pode encolher a carga útil do clone de muitos gigabytes para apenas o snapshot da revisão mais recente, reduzindo drasticamente o tempo de clonagem. Os desenvolvedores que precisam de um histórico mais antigo podem executar posteriormente `git fetch --unshallow` ou `git fetch --depth=N` para baixar incrementalmente commits adicionais, e o clone continua sendo um repositório normal capaz de receber alterações em qualquer parte do monorepo.

C

Incorreta

Mova todos os arquivos binários grandes para o Git LFS para reduzir o tamanho do repositório.

O Git LFS já está em uso neste repositório, portanto os arquivos binários grandes já estão armazenados fora do pack e referenciados por arquivos de ponteiro. Mover arquivos adicionais para o LFS exigiria uma reescrita do histórico para substituir os blobs existentes por ponteiros, e mesmo assim o efeito na clonagem inicial é nulo porque os ponteiros LFS são minúsculos e o conteúdo real do blob não é transferido durante a clonagem; ele é buscado sob demanda no checkout. Assim, essa ação não reduz o pack do Git que domina o tempo de clonagem e introduz uma reescrita disruptiva do repositório.

D

Incorreta

Divida o monorepo em vários repositórios e use submódulos para agregá-los.

Dividir o monorepo e agregar via submódulos aumenta a sobrecarga administrativa e quebra os commits atômicos entre projetos, mas o mais importante é que não reduz o tempo total de clonagem para desenvolvedores que precisam de mais de um projeto: clonar apenas o superprojeto não busca o conteúdo dos submódulos, e inicializar e atualizar cada submódulo requer solicitações de rede e espaço em disco adicionais. Além disso, os ponteiros de submódulo devem ser cuidadosamente sincronizados, e um clone superficial do superprojeto não clona superficialmente os submódulos automaticamente, muitas vezes fazendo com que a mesma quantidade de dados seja baixada em vários repositórios.

Para se aprofundar

O desempenho do git clone é determinado principalmente pelo número e tamanho dos objetos que devem ser transferidos pela rede. Um monorepo acumula milhares de commits, cada um com árvores e blobs para todos os arquivos, de modo que um clone completo baixa todas as versões históricas de cada arquivo. O clone superficial explora o fato de que a maioria dos desenvolvedores precisa apenas do snapshot atual, limitando o histórico a uma profundidade especificada, evitando assim a grande maioria dos objetos. O sparse checkout, por outro lado, restringe apenas a árvore de trabalho após a chegada de todos os objetos, e muitas vezes assume-se erroneamente que ele acelera as clonagens. Os clones parciais (por exemplo, `--filter=blob:none`) são a solução mais avançada que combina os benefícios de ambos, mas não estão listados aqui. Os usuários do Azure Repos no mundo real frequentemente combinam `--depth 1` com `--sparse` e `--filter=blob:none` para obter tempos de clonagem mínimos, mantendo a capacidade de trabalhar em um subconjunto de um monorepo grande. Compreender esses mecanismos distintos é crucial para selecionar a otimização correta e evitar compensações enganosas.

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.