Compartir a través de

Incorporación de la integración continua a las compilaciones de contenedor

  • Artículo

Importante

Esta es la documentación de Azure Sphere (heredado). Azure Sphere (heredado) se retira el 27 de septiembre de 2027 y los usuarios deben migrar a Azure Sphere (integrado) en este momento. Use el selector de versiones situado encima de la TOC para ver la documentación de Azure Sphere (integrado).

La integración continua es un proceso de desarrollo de software en el que una aplicación se mantiene en un estado liberable continuamente proporcionando compilaciones automatizadas con cada confirmación en una base de código específica. Puede agregar integración continua a prácticamente cualquier sistema de compilación, pero dos que son especialmente convenientes son Acciones de GitHub y Azure Pipelines. En este tema, verá cómo usar Acciones de GitHub o Azure Pipelines para automatizar los pasos de compilación de Docker descritos en Uso de contenedores para compilar aplicaciones de Azure Sphere.

Uso de Acciones de GitHub para compilar automáticamente el contenedor

Acciones de GitHub permite automatizar el proceso de compilación directamente desde los repositorios de GitHub. Por lo tanto, el primer paso para usar Acciones de GitHub es crear o abrir un repositorio de GitHub que contenga el código de la aplicación. En este tema se supone que ha creado un repositorio de GitHub que contiene la aplicación Blink generada en Tutorial: Compilación de una aplicación de alto nivel y que el proyecto se denomina "Blink". Al igual que con cualquier proyecto de integración continua, asegúrese de que el proyecto se compila localmente y proporciona los artefactos esperados antes de intentar automatizar el proceso. En este ejemplo, se supone que después de una compilación correcta, el out directorio contiene un archivo Blink.imagepackage.

En el directorio de nivel superior del repositorio de GitHub, cree un directorio denominado .devcontainer y cree un archivo denominado Dockerfile en ese directorio con el siguiente contenido:

FROM mcr.microsoft.com/azurespheresdk:latest AS dev

FROM dev AS build
COPY ./ /src/
WORKDIR /out
RUN cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE="/opt/azurespheresdk/CMakeFiles/AzureSphereToolchain.cmake" \
    -DAZURE_SPHERE_TARGET_API_SET="latest-lts" -DCMAKE_BUILD_TYPE="Release" "/src"
ENTRYPOINT [ "ninja" ]

La línea inicial FROM especifica la imagen estándar de Docker de Azure Sphere como contenedor de desarrollo base y la segunda indica que usa ese contenedor base como entorno de compilación. La COPY línea copia el contenido del repositorio en el directorio /src/ del contenedor. WORKDIR especifica el directorio de compilación. El RUN comando proporciona el comando CMake para generar los archivos de compilación. Por último, especifica ENTRYPOINT que se debe invocar ninja para compilar realmente la aplicación.

En el directorio de nivel superior del repositorio, cree el directorio .github/workflows y agregue un archivo denominado ci.yml con el siguiente contenido:

# This is a basic workflow to help you get started with Actions

name: ContinuousIntegration

# Controls when the action will run. Triggers the workflow on push or pull request
# events, but including workflow_dispatch also allows manual execution
on:
  push:
  pull_request:
  workflow_dispatch:


jobs:
  build:
    runs-on: ubuntu-latest
    name: Build Azure Sphere Apps
    steps:
    - name: Checkout
      uses: actions/checkout@v2
    - name: Build image for azsphere builds and Start container from build image
      run: |
        docker build --target build -t hlbuildimage -f .devcontainer/Dockerfile .
        docker run --name hlbuildcontainer hlbuildimage
    - name: Copy container build output
      run:
        docker cp hlbuildcontainer:/out HLOutput
    - name: Publish HL imagepackage
      uses: actions/upload-artifact@v2
      with:
        name: HL imagepackage
        path: ${{ github.workspace }}/HLOutput/Blink.imagepackage

Este flujo de trabajo solo tiene un trabajo para compilar la aplicación; el trabajo se ejecuta en un ejecutor de Acciones de GitHub, en este caso ubuntu-latest, y tiene cuatro pasos:

  1. Paso 1, Checkout, es una acción estándar de GitHub que simplemente comprueba el repositorio en el ejecutor más reciente de Ubuntu.

  2. El paso 2 compila la imagen (docker build) e inicia el contenedor (docker run).

  3. El paso 3 copia la salida del contenedor en el ejecutor.

  4. Paso 4: Publicar el paquete de imágenes HL, publica el paquete de imágenes de aplicación de alto nivel como un artefacto.

Confirme estos cambios en la rama principal y seleccione Acciones. Ahora debería ver una página con la etiqueta "Todos los flujos de trabajo", con al menos un flujo de trabajo en ejecución o completado. Si el flujo de trabajo se completa correctamente, aparece una marca de verificación verde junto a ella. Haga clic en un flujo de trabajo correcto y debería ver un cuadro con la etiqueta "Artefactos" que contiene un artefacto con la etiqueta "HL imagepackage". Descargue este artefacto y desempaquete el archivo imagepackage; Después, puede crear una implementación o transferir localmente la aplicación al dispositivo.

Uso de Azure Pipelines para compilar automáticamente el contenedor

Azure Pipelines permite automatizar el proceso de compilación directamente desde los repositorios de GitHub (y muchos otros repositorios de código). En este tema se supone que ya pertenece a una organización con un proyecto de Azure DevOps y tiene acceso a Azure Pipelines. El primer paso para usar Azure Pipelines es crear o abrir un repositorio que contenga el código de la aplicación. En este tema se supone que ha creado un repositorio de GitHub que contiene la aplicación Blink generada en Tutorial: Compilación de una aplicación de alto nivel.

En el directorio de nivel superior de este repositorio, cree el directorio .devcontainer y cree un archivo Dockerfile en ese directorio con el siguiente contenido:

FROM mcr.microsoft.com/azurespheresdk:latest AS dev

FROM dev AS build
COPY ./ /src/
WORKDIR /out
RUN cmake -G "Ninja" -DCMAKE_TOOLCHAIN_FILE="/opt/azurespheresdk/CMakeFiles/AzureSphereToolchain.cmake" \
    -DAZURE_SPHERE_TARGET_API_SET="latest-lts" -DCMAKE_BUILD_TYPE="Release" "/src"
ENTRYPOINT [ "ninja" ]

La línea inicial FROM especifica la imagen estándar de Docker de Azure Sphere como contenedor de desarrollo base y la segunda indica que usa ese contenedor base como entorno de compilación. La COPY línea copia el contenido del repositorio en el directorio /src/ del contenedor. WORKDIR especifica el directorio de compilación. El RUN comando proporciona el comando CMake para generar los archivos de compilación. Por último, especifica ENTRYPOINT que se debe invocar ninja para compilar realmente la aplicación.

Para crear la canalización:

  1. Inicie sesión en el proyecto de Azure DevOps y abra Pipelines.
  2. Seleccione Nueva canalización y, a continuación, seleccione GitHub cuando se le pregunte ¿Dónde está el código? Se le puede llevar a una página de autenticación de GitHub; complete la autenticación y continúe con la página para seleccionar el repositorio.
  3. Seleccione el repositorio blink. Se le lleva a una página denominada Configurar la canalización.
  4. Seleccione Canalización inicial. Se abre un archivo denominado azure-pipelines.yml en el directorio de nivel superior del repositorio con una tarea Hola mundo.
  5. Seleccione Guardar y ejecutar. Acepte el mensaje de confirmación predeterminado y, de nuevo, seleccione Guardar y ejecutar. El archivo azure-pipelines.yml se confirma en el repositorio de GitHub y se crea la canalización.

Reemplace el contenido del archivo azure-pipelines.yml por el siguiente contenido:

# Docker
# Build a Docker image
# https://learn.microsoft.com/azure/devops/pipelines/languages/docker

trigger:
- main

resources:
- repo: self

variables:
  tag: '$(Build.BuildId)'

stages:
- stage: Build
  displayName: Build image
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - bash: docker build --target build -t hlbuildimage -f .devcontainer/Dockerfile . &&  docker run --name hlbuildcontainer hlbuildimage && docker cp hlbuildcontainer:/out $(Build.ArtifactStagingDirectory)/HLOutput
      displayName: Build high-level Azure Sphere application in a container and copy the output
    - task: PublishBuildArtifacts@1
      displayName: Publish build artifacts
      inputs:
        PathtoPublish: '$(Build.ArtifactStagingDirectory)/HLOutput/Blink.imagepackage'
        ArtifactName: 'BlinkSample.imagepackage'
        publishLocation: 'Container'

Este flujo de trabajo solo tiene un trabajo para compilar la aplicación; el trabajo se ejecuta en un agente de Azure DevOps, en este caso ubuntu-latest, y tiene dos pasos:

  1. El paso 1 compila la imagen (docker build), inicia el contenedor (docker run) y copia la salida del contenedor en el agente.

  2. Paso 2: Publicar artefactos de compilación, publica el paquete de imágenes de aplicación de alto nivel como un artefacto.

Confirme estos cambios en la rama principal. En Azure DevOps, vuelva a abrir Pipelines . Debería ver una ejecución de la canalización en curso o simplemente completada. Si la ejecución muestra una marca de verificación verde, la compilación se realizó correctamente. Seleccione la ejecución correcta; Debería ver 1 Publicado en la columna Relacionado . Descargue este artefacto y descomprima el archivo imagepackage; Después, puede crear una implementación o transferir localmente la aplicación al dispositivo.

Incorporación de la integración continua a aplicaciones de ejemplo de Azure Sphere

Acciones de GitHub y Azure Pipelines están diseñados para automatizar compilaciones para un solo proyecto, como los descargados desde el explorador de ejemplos de Microsoft. Los ejemplos de Azure Sphere en GitHub son una colección de proyectos con algunos recursos compartidos. Para usar uno de estos ejemplos en la integración continua, debe incorporar los recursos compartidos necesarios. Normalmente, esto significa al menos crear un directorio HardwareDefinitions en el directorio de nivel superior del proyecto y editar el archivo CMakeLists.txt para que apunte a la copia local. Por ejemplo, si crea un proyecto basado en el ejemplo HelloWorld/HelloWorld_HighLevelApp, el directorio de nivel superior tiene un aspecto similar al siguiente:

.vscode
.gitignore
applibs_versions.h
app_manifest.json
CMakeLists.txt
CMakeSettings.json
launch.vs.json
LICENSE.txt
main.c
README.md

El archivo CMakeLists.txt contiene la siguiente línea que apunta al directorio HardwareDefinitions compartido en el repositorio de ejemplos:

azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "../../../HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "sample_appliance.json")

Para permitir que el proyecto se compile, copie la carpeta HardwareDefinitions en el directorio de nivel superior y, a continuación, edite el archivo CMakeLists.txt para usar la ubicación local:

azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "sample_appliance.json")

De nuevo, compruebe que el proyecto se compila localmente antes de intentar automatizar con Acciones de GitHub.