Partilhar via

Adicionar integração contínua às compilações de contentor

  • Artigo

A integração contínua é um processo de desenvolvimento de software no qual uma aplicação é mantida num estado de libertação contínua ao fornecer compilações automatizadas com cada consolidação para uma base de código específica. Pode adicionar integração contínua a praticamente qualquer sistema de compilação, mas dois que são particularmente convenientes são GitHub Actions e os Pipelines do Azure. Neste tópico, verá como utilizar GitHub Actions ou os Pipelines do Azure para automatizar os passos de compilação do Docker descritos em Utilizar contentores para criar aplicações do Azure Sphere.

Utilizar GitHub Actions para criar automaticamente o contentor

GitHub Actions permitem automatizar o processo de compilação diretamente a partir dos repositórios do GitHub. Assim, o primeiro passo na utilização do GitHub Actions é criar ou abrir um repositório do GitHub que contenha o código da aplicação. Este tópico pressupõe que criou um repositório do GitHub que contém a aplicação Blink gerada no Tutorial: Criar uma aplicação de alto nível e que o projeto tem o nome "Blink". Tal como acontece com qualquer projeto de integração contínua, certifique-se de que o projeto é criado localmente e fornece os artefactos esperados antes de tentar automatizar o processo. Neste exemplo, partimos do princípio de que, após uma compilação com êxito, o out diretório contém um ficheiro Blink.imagepackage.

No diretório de nível superior do seu repositório do GitHub, crie um diretório com o nome .devcontainer e crie um ficheiro com o nome Dockerfile nesse diretório com o seguinte conteúdo:

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" ]

A linha inicial FROM especifica a imagem padrão do Docker do Azure Sphere como o contentor de desenvolvimento base e a segunda diz para utilizar esse contentor base como o ambiente de compilação. A COPY linha copia o conteúdo do repositório para o diretório /src/ do contentor. Especifica WORKDIR o diretório build. O RUN comando fornece o comando CMake para gerar os ficheiros de compilação. Por fim, o ENTRYPOINT especifica que ninja deve ser invocado para realmente criar a aplicação.

No diretório de nível superior do seu repositório, crie o diretório .github/workflows e adicione um ficheiro com o nome ci.yml com o seguinte conteúdo:

# 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 az sphere 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 fluxo de trabalho tem apenas uma tarefa: criar a aplicação; a tarefa é executada num GitHub Actions runner, neste caso ubuntu-latest, e tem quatro passos:

  1. O passo 1, Checkout, é uma ação padrão do GitHub que simplesmente dá saída do seu repositório para a execução mais recente do ubuntu.

  2. O passo 2 compila a imagem (docker build) e inicia o contentor (docker run).

  3. O passo 3 copia a saída do contentor para o corredor.

  4. Passo 4, Publicar imagepackage HL, publica o pacote de imagens de aplicação de alto nível como um artefacto.

Consolide estas alterações no ramo principal e selecione Ações. Deverá agora ver uma página com o nome "Todos os fluxos de trabalho", com, pelo menos, um fluxo de trabalho em execução ou concluído. Se o fluxo de trabalho for concluído com êxito, é apresentada uma marca de verificação verde junto ao mesmo. Clique num fluxo de trabalho com êxito e deverá ver uma caixa com o nome "Artefactos" que contém um artefacto com o nome "HL imagepackage". Transfira este artefacto e descompacte o ficheiro imagepackage; em seguida, pode criar uma implementação ou fazer sideload da aplicação para o seu dispositivo.

Utilizar o Azure Pipelines para compilar automaticamente o contentor

Os Pipelines do Azure permitem-lhe automatizar o processo de compilação diretamente a partir dos repositórios do GitHub (e de muitos outros repositórios de código). Este tópico pressupõe que já pertence a uma organização com um projeto do Azure DevOps e tem acesso aos Pipelines do Azure. O primeiro passo na utilização do Azure Pipelines é criar ou abrir um repositório que contenha o código da aplicação. Este tópico pressupõe que criou um repositório do GitHub que contém a aplicação Blink gerada no Tutorial: Criar uma aplicação de alto nível.

No diretório de nível superior deste repositório, crie o diretório .devcontainer e crie um ficheiro Dockerfile nesse diretório com o seguinte conteúdo:

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" ]

A linha inicial FROM especifica a imagem padrão do Docker do Azure Sphere como o contentor de desenvolvimento base e a segunda diz para utilizar esse contentor base como o ambiente de compilação. A COPY linha copia o conteúdo do repositório para o diretório /src/ do contentor. Especifica WORKDIR o diretório build. O RUN comando fornece o comando CMake para gerar os ficheiros de compilação. Por fim, o ENTRYPOINT especifica que ninja deve ser invocado para realmente criar a aplicação.

Para criar o pipeline:

  1. Inicie sessão no projeto do Azure DevOps e abra Pipelines.
  2. Selecione Novo Pipeline e, em seguida, selecione GitHub quando lhe for perguntado Onde está o código? Pode ser levado para uma página de autenticação do GitHub; conclua a autenticação e continue para a página para selecionar o seu repositório.
  3. Selecione o seu repositório Blink. É levado para uma página intitulada Configurar o pipeline.
  4. Selecione Pipeline de arranque. Esta ação abre um ficheiro com o nome azure-pipelines.yml no diretório de nível superior do seu repositório com uma tarefa Hello, World.
  5. Selecione Guardar e executar. Aceite a mensagem de consolidação predefinida e selecione Novamente Guardar e executar. O ficheiro azure-pipelines.yml é consolidado no seu repositório do GitHub e o pipeline é criado.

Substitua o conteúdo do ficheiro azure-pipelines.yml pelo seguinte conteúdo:

# Docker
# Build a Docker image
# /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 fluxo de trabalho tem apenas uma tarefa: criar a aplicação; a tarefa é executada num agente do Azure DevOps, neste caso ubuntu-latest, e tem dois passos:

  1. O passo 1 compila a imagem (docker build), inicia o contentor (docker run) e copia a saída do contentor para o agente.

  2. Passo 2, Publicar artefactos de compilação, publica o imagepackage de aplicação de alto nível como um artefacto.

Consolide estas alterações no ramo principal. No Azure DevOps, abra pipelines novamente. Deverá ver uma execução do pipeline em curso ou concluída. Se a execução mostrar uma marca de verificação verde, a compilação foi efetuada com êxito. Selecione a execução com êxito; deverá ver 1 Publicado na coluna Relacionados . Transfira este artefacto e deszipe o ficheiro imagepackage; em seguida, pode criar uma implementação ou fazer sideload da aplicação para o seu dispositivo.

Adicionar integração contínua a aplicações de exemplo do Azure Sphere

GitHub Actions e os Pipelines do Azure destinam-se a automatizar compilações para um único projeto, como as transferidas a partir do browser de exemplos da Microsoft. Os Exemplos do Azure Sphere no GitHub são uma coleção de projetos com alguns recursos partilhados. Para utilizar um destes exemplos na integração contínua, tem de incorporar todos os recursos partilhados necessários. Normalmente, isto significa, pelo menos, criar um diretório HardwareDefinitions no diretório de nível superior do projeto e editar o ficheiro CMakeLists.txt para apontar para a cópia local. Por exemplo, se criar um projeto com base no exemplo HelloWorld/HelloWorld_HighLevelApp, o diretório de nível superior terá inicialmente o seguinte aspeto:

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

O ficheiro CMakeLists.txt contém a seguinte linha que aponta para o diretório HardwareDefinitions partilhado no repositório Samples:

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

Para permitir a compilação do projeto, copie a pasta HardwareDefinitions para o diretório de nível superior e, em seguida, edite o ficheiro CMakeLists.txt para utilizar a localização local:

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

Novamente, verifique se o projeto é compilado localmente antes de tentar automatizar com GitHub Actions.