Planejar as tarefas de build

  • 7 minutos

Clara agora tem uma cópia do código de Space Game. Ela o criará usando o Microsoft Azure Pipelines em vez do servidor de build Ubuntu 22.04 existente. Para fazer isso, ela precisará pensar sobre os scripts de build existentes. Acompanhe-a enquanto ela mapeia os scripts existentes para tarefas do Azure Pipelines. Pense em como você pode fazer o mesmo com seu próprio processo de build.

Veja algumas observações que Clara extraiu da conversa com Paulo, o líder de desenvolvimento:

  • O computador de build executa o Ubuntu 22.04.
  • O computador de build inclui ferramentas de build como:
    • npm, o gerenciador de pacotes do Node.js
    • NuGet, o gerenciador de pacotes do .NET
    • SDK .NET
  • O projeto usa Sass (Syntactically Awesome Style Sheets) para facilitar a criação de arquivos CSS (folhas de estilo em cascata).
  • O projeto usa o kit de ferramentas gulp para minificar arquivos JavaScript e CSS.

Um ativo minificado exclui dados desnecessários, como espaço em branco, e reduz os nomes de variáveis para ajudá-lo a ser baixado mais rapidamente.

Estas são as etapas que ocorrem durante o processo de build:

  1. Para instalar os pacotes do Node.js definidos em package.json, execute npm install.
  2. Para converter arquivos Sass (.scss) em CSS (.css), execute node-sass.
  3. Para minificar os arquivos JavaScript e CSS, execute gulp.
  4. Para ajudar a equipe de garantia de qualidade a identificar a data e o número de build, imprima as informações do build no diretório wwwroot.
  5. Para instalar as dependências do projeto, execute dotnet restore.
  6. Para compilar o aplicativo nas configurações de Depuração e Versão, execute dotnet build.
  7. Para empacotar o aplicativo como um arquivo .zip e copiar os resultados para um compartilhamento de rede para a equipe de garantia de qualidade selecionar, execute dotnet publish.

Clara compila um script de shell que executa as tarefas que ela identificou. Ela o executa no laptop.

Observação

Você não precisa executar esse script nem entender por completo o que ele faz. Ele está aqui para ilustrar o que um script de build típico pode fazer.

#!/bin/bash

# Install Node.js modules as defined in package.json.
npm install --quiet

# Compile Sass (.scss) files to standard CSS (.css).
node-sass Tailspin.SpaceGame.Web/wwwroot

# Minify JavaScript and CSS files.
gulp

# Print the date to wwwroot/buildinfo.txt.
echo `date` > Tailspin.SpaceGame.Web/wwwroot/buildinfo.txt

# Install the latest .NET packages the app depends on.
dotnet restore

# Build the app under the Debug configuration.
dotnet build --configuration Debug

# Publish the build to the /tmp directory.
dotnet publish --no-build --configuration Debug --output /tmp/Debug

# Build the app under the Release configuration.
dotnet build --configuration Release

# Publish the build to the /tmp directory.
dotnet publish --no-build --configuration Release --output /tmp/Release

O diretório /tmp imita o compartilhamento de rede da equipe.

Depois de executar o script, Clara percebe que ele está incompleto. Por exemplo, ele não lida com erros. Ele não notificará ninguém se ocorrerem erros de build. Mesmo quando há erros, ele continua em execução. Ele também não instala as ferramentas necessárias para cada etapa.

Quais são as tarefas do Azure Pipelines?

No Azure Pipelines, uma tarefa é um script ou procedimento empacotado que foi abstraído com um conjunto de entradas.

Uma tarefa do Azure Pipelines abstrai os detalhes subjacentes. Essa abstração facilita a execução de funções de build comuns, como baixar ferramentas de build ou pacotes dos quais seu aplicativo depende, ou a criação do seu projeto, executando o Visual Studio ou o Xcode.

Para criar um projeto do C# direcionado ao .NET, veja um exemplo que usa a tarefa DotNetCoreCLI@2:

task: DotNetCoreCLI@2
  displayName: 'Build the project'
  inputs:
    command: 'build'
    arguments: '--no-restore --configuration Release'
    projects: '**/*.csproj'

O pipeline pode converter essa tarefa neste comando:

dotnet build MyProject.csproj --no-restore --configuration Release

Vamos detalhar essa tarefa um pouco mais:

  • A tarefa DotNetCoreCLI@2 é mapeada para o comando dotnet.
  • displayName define o nome da tarefa que é mostrado na interface do usuário. Você verá isso em ação em breve.
  • inputs define os argumentos passados para o comando.
    • command especifica para executar o subcomando dotnet build.
    • arguments especifica argumentos adicionais a serem passados para o comando.
    • projects especifica quais projetos serão compilados. Este exemplo usa o padrão de curinga **/*.csproj. ** e *.csproj são exemplos do que é chamado padrões glob. A parte ** especifica a pesquisa no diretório atual e em todos os diretórios filho. A parte *.csproj especifica qualquer arquivo .csproj. Os curingas permitem que você execute ações sobre vários arquivos sem especificar cada um deles. Caso precise executar uma ação em apenas um arquivo específico, especifique esse arquivo em vez de usar curingas.

O "@" no nome da tarefa, por exemplo DotNetCoreCLI@2, refere-se à versão da tarefa. Conforme novas versões de tarefa ficam disponíveis, você pode migrar gradualmente para a última versão para aproveitar os novos recursos.

Como as tarefas são usadas em um pipeline?

Em seguida, Clara mapeará os comandos de script existentes para tarefas do Azure Pipelines. Um pipeline é criado usando um arquivo YAML, que é um formato compacto que facilita a estruturação do tipo de dados que está nos arquivos de configuração. Normalmente, os arquivos YAML de pipeline são mantidos diretamente no código-fonte do aplicativo.

Marina usou o YAML anteriormente para definir configurações e tarefas de build semelhantes. Além disso, ela gosta da ideia de manter a definição de build como um código, exatamente como faria com qualquer outra parte do projeto.

Para definir o build, Clara opta por usar o Visual Studio Code para criar um arquivo YAML. Nele, ela insere todas as tarefas do Azure Pipelines que usará para substituir os comandos de script existentes.

Mapear os comandos de script para tarefas do Azure Pipelines

Agora, você acompanhará Clara enquanto ela mapeia comandos do script para tarefas do Azure Pipelines.

Para mapear cada comando, Clara vê a documentação de referência. A documentação categoriza as tarefas pela função, como compilar ou implantar.

Por exemplo, a tarefa CLI do .NET Core DotNetCoreCLI@2 ajuda a executar dotnet comandos.

Essa tabela associa os comandos de script às novas tarefas do Azure Pipelines:

Comando de script Tarefa do Azure Pipelines
npm install Npm@1
node-sass CmdLine@2(ou script)
gulp gulp@1
echo `date` CmdLine@2(ou script)
dotnet restore DotNetCoreCLI@2
dotnet build DotNetCoreCLI@2
dotnet publish DotNetCoreCLI@2

Não há nenhum tipo de tarefa interno que execute node-sass ou imprima a data no arquivo. Para elas, Clara usa a tarefa CmdLine@2, que permite executar qualquer comando desejado. Mais comumente, você verá a tarefa script, que é um atalho para CmdLine@2. Para obter mais informações sobre os outros atalhos de tarefa comuns, confira Referência de esquema YAML para Azure Pipelines – Etapas.

Em breve, você criará o próprio arquivo YAML que usa essas tarefas.

Verificar seu conhecimento

1.

Uma tarefa de build: