Planeación de las tareas de compilación

  • 7 minutos

Ahora, Mara tiene una copia del código de Space Game. Lo va a compilar con Microsoft Azure Pipelines en lugar del servidor de compilación existente de Ubuntu 22.04. Para poder hacerlo, debe pensar en los scripts de compilación existentes. Siga los pasos de Mara mientras asigna los scripts existentes a tareas de Azure Pipelines. Piense en cómo puede hacer lo mismo en su propio proceso de compilación.

Estas son algunas de las notas que Mara ha recopilado al hablar con Andy, el responsable de desarrollo:

  • La máquina de compilación ejecuta Ubuntu 22.04.
  • La máquina de compilación incluye herramientas de compilación como las siguientes:
    • npm, el administrador de paquetes de Node.js.
    • NuGet, el administrador de paquetes de .NET.
    • .NET SDK
  • El proyecto utiliza hojas de estilo sintácticamente impresionantes (Sass) para facilitar la creación de archivos de hojas de estilo CSS.
  • El proyecto usa el kit de herramientas de gulp para minimizar los archivos JavaScript y CSS.

Un activo minimizado excluye los datos innecesarios (como los espacios en blanco) y acorta los nombres de variable para lograr descargas más rápidas.

Estos son los pasos que tienen lugar durante el proceso de compilación:

  1. Ejecución de npm install para instalar los paquetes de Node.js definidos en package.json.
  2. Ejecución de node-sass para convertir los archivos Sass (.scss) en archivos CSS (.css).
  3. Ejecución de gulp para minimizar los archivos JavaScript y CSS.
  4. Imprima la información de compilación en el directorio wwwroot para ayudar al equipo de control de calidad a identificar la fecha y el número de compilación.
  5. Ejecución de dotnet restore para instalar las dependencias del proyecto.
  6. Para compilar la aplicación en las configuraciones tanto Debug como Release, ejecute dotnet build.
  7. Ejecución de dotnet publish para empaquetar la aplicación como un archivo .zip y copiar los resultados en un recurso compartido de red para que pueda seleccionarlo el equipo de control de calidad.

Mara crea un script de shell que realiza las tareas que ha identificado y lo ejecuta en su equipo portátil.

Nota:

No es necesario que ejecute este script ni entender totalmente lo que hace. Lo incluimos aquí para ilustrar lo que un script de compilación normal puede hacer.

#!/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

El directorio /tmp imita el recurso compartido de red del equipo.

Tras ejecutar el script, Mara se percata de que está incompleto. Por ejemplo, no hace nada con los errores. No notifica a nadie si se producen errores de compilación. Incluso cuando hay errores, sigue ejecutándose. Tampoco instala las herramientas que cada paso requiere.

¿Qué es una tarea de Azure Pipelines?

En Azure Pipelines, una tarea es un procedimiento o script empaquetado que se ha abstraído con un conjunto de entradas.

Una tarea Azure Pipelines abstrae los detalles subyacentes. Esta abstracción facilita la ejecución de funciones de compilación comunes, como la descarga de herramientas de compilación o paquetes de los que depende la aplicación, o la compilación del proyecto, ejecutando Visual Studio o Xcode.

Este es un ejemplo que usa la tarea DotNetCoreCLI@2 para compilar un proyecto de C# destinado a .NET:

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

La canalización puede convertir esta tarea en este comando:

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

Vamos a desglosar esta tarea un poco más:

  • La tarea DotNetCoreCLI@2 se asigna al comando dotnet.
  • displayName define el nombre de tarea que aparece en la interfaz de usuario. Veremos esto en acción en breve.
  • inputs define los argumentos que se pasan al comando.
    • command especifica que se ejecute el subcomando dotnet build.
    • arguments especifica más argumentos para pasarlos al comando.
    • projects especifica qué proyectos se van a compilar. En este ejemplo se usa el patrón de caracteres comodín **/*.csproj. Tanto ** como *.csproj son ejemplos de lo que se denomina patrones globales. La parte ** especifica que se busque en el directorio actual y en todos los directorios secundarios. La parte *.csproj especifica cualquier archivo .csproj. Los caracteres comodín permiten actuar en varios archivos sin necesidad de especificar cada uno de ellos. Si solo tiene que actuar en un archivo específico, puede especificar ese archivo en lugar de usar caracteres comodín.

El signo de arroba "@" en el nombre de la tarea como, por ejemplo, DotNetCoreCLI@2, hace referencia a la versión de la tarea. A medida que vayan saliendo disponibles nuevas versiones de la tarea, puede migrar gradualmente a la versión más reciente para aprovechar las nuevas características.

¿Cómo se usan las tareas en una canalización?

Lo siguiente que Mara hará será asignar los comandos de scripts existentes a tareas de Azure Pipelines. Se crea una canalización con un archivo YAML, que es un formato compacto que facilita la estructuración del tipo de datos que se encuentra en los archivos de configuración. Normalmente, los archivos YAML de canalización se mantienen directamente con el código fuente de la aplicación.

Mara ha utilizado YAML antes para definir configuraciones y tareas de compilación similares. Y, además, le gusta la idea de mantener la definición de la compilación como código, como cualquier otra parte del proyecto.

Para definir la compilación, Mara decide usar Visual Studio Code para crear un archivo YAML. En él, escribe todas las tareas de Azure Pipelines que usará para reemplazar los comandos de scripts existentes.

Asignación de comandos de scripts a tareas de Azure Pipelines

Ahora, veremos cómo Mara asigna comandos desde su script a tareas de Azure Pipelines.

Para asignar cada comando, Mara se remite a la documentación de referencia. La documentación categoriza las tareas por función, como compilar o implementar.

Por ejemplo, la tarea de la CLI de .NET CoreDotNetCoreCLI@2 ayuda a ejecutar los comandos dotnet.

En esta tabla, los comandos de script se asocian a las tareas nuevas de Azure Pipelines:

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

No hay ningún tipo de tarea integrada que ejecute node-Sass o que imprima la fecha en un archivo. Para estas, Mara usa la tarea CmdLine@2, que permite ejecutar cualquier comando que quiera. Lo normal es ver la tarea script, que es un método abreviado de CmdLine@2. Para obtener más información sobre los demás métodos abreviados de tareas comunes, consulte Referencia del esquema YAML para Azure Pipelines: pasos.

En breve, creará un archivo YAML propio que use estas tareas.

Comprobación de conocimientos

1.

Una tarea de compilación: