Planeje suas tarefas de compilação

  • 7 minutos

Mara agora tem uma cópia do código do Jogo Espacial. Ela vai criá-lo usando o Microsoft Azure Pipelines em vez do servidor de compilação existente do Ubuntu 22.04. Antes de fazer isso, ela precisa pensar sobre os scripts de construção existentes. Acompanhe 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 construção.

Aqui estão algumas notas que Mara coletou quando conversou com Andy, o líder de desenvolvimento:

  • A máquina de compilação está executando o Ubuntu 22.04.
  • A máquina de construção inclui ferramentas de construção como:
    • npm, o gestor de pacotes para Node.js
    • NuGet, o gerenciador de pacotes para .NET
    • SDK do .NET
  • O projeto usa Syntatally Awesome Style Sheets (Sass) para facilitar a criação de arquivos CSS (folhas de estilo em cascata).
  • O projeto usa o kit de ferramentas gulp para minar arquivos JavaScript e CSS.

Um ativo minificado exclui dados desnecessários (como espaços em branco) e encurta nomes de variáveis para ajudá-lo a baixar mais rapidamente.

Aqui estão as etapas que acontecem durante o processo de compilação:

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

Mara constrói um shell script que executa as tarefas que ela identificou. Ela o executa em seu laptop.

Nota

Você não precisa executar esse script ou entender completamente o que ele faz. Está aqui para ilustrar o que um script de construção 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 /tmp diretório imita o compartilhamento de rede da equipe.

Depois de executar o roteiro, Mara percebe que ele está incompleto. Por exemplo, não lida com erros. Ele não notifica ninguém se ocorrerem erros de compilação. Mesmo quando há erros, ele continua funcionando. Ele também não instala as ferramentas que cada etapa exige.

O que são 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 compilação comuns, como baixar ferramentas de compilação ou pacotes dos quais seu aplicativo depende, ou criar seu projeto, executando Visual Studio ou Xcode.

Para criar um projeto C# destinado ao .NET, aqui está um exemplo que usa a DotNetCoreCLI@2 tarefa:

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

O pipeline pode traduzir essa tarefa para este comando:

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

Vamos detalhar um pouco mais essa tarefa:

  • A DotNetCoreCLI@2 tarefa é mapeada para o dotnet comando.
  • displayName Define o nome da tarefa mostrado na interface do usuário. Você verá isso em ação em breve.
  • inputs define os argumentos que são passados para o comando.
    • command especifica para executar o dotnet build subcomando.
    • arguments Especifica argumentos adicionais a serem passados para o comando.
    • projects Especifica quais projetos compilar. Este exemplo usa o padrão **/*.csprojcuringa . Ambos ** e *.csproj são exemplos do que são chamados padrões glob. A ** parte especifica para pesquisar o diretório atual e todos os diretórios filho. A *.csproj parte especifica qualquer arquivo .csproj . Os curingas permitem que você aja em vários arquivos sem especificar cada um. Se você precisar agir somente em um arquivo específico, poderá especificar esse arquivo em vez de usar curingas.

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

Como as tarefas são usadas em um pipeline?

Em seguida, Mara vai 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ão nos arquivos de configuração. Os arquivos YAML de pipeline geralmente são mantidos diretamente com o código-fonte do seu aplicativo.

Mara usou o YAML anteriormente para definir tarefas e configurações de compilação semelhantes. Ela também gosta da ideia de manter a definição de construção como código, assim como faria com qualquer outra parte de seu projeto.

Para definir sua compilação, Mara escolhe 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 comandos de script para tarefas do Azure Pipelines

Agora, você acompanhará enquanto Mara mapeia comandos de seu script para tarefas do Azure Pipelines.

Para mapear cada comando, Mara refere-se à documentação de referência. A documentação categoriza tarefas por função, como build ou deploy.

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

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

Comando 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 interna que execute node-sass ou imprima a data em um arquivo. Para isso, Mara usa a CmdLine@2 tarefa, que lhe permite executar qualquer comando que quiser. Mais comumente, você verá a script tarefa, que é um atalho para CmdLine@2. Para obter mais informações sobre os outros atalhos de tarefas comuns, consulte Referência de esquema YAML para Pipelines do Azure - etapas.

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

Verifique o seu conhecimento

1.

Uma tarefa de compilação: