Dela via

Lägga till kontinuerlig integrering i behållarversioner

  • Artikel

Kontinuerlig integrering är en programvaruutvecklingsprocess där ett program hålls i ett ständigt utgivningsbart tillstånd genom att tillhandahålla automatiserade versioner med varje åta sig till en viss kodbas. Du kan lägga till kontinuerlig integrering i praktiskt taget alla byggsystem, men två som är särskilt praktiska är GitHub Actions och Azure Pipelines. I det här avsnittet får du se hur du använder antingen GitHub Actions eller Azure Pipelines för att automatisera stegen i Docker-versionen som beskrivs i Använda behållare för att skapa Azure Sphere-appar.

Använd GitHub Actions för att automatiskt bygga din behållare

GitHub Actions kan du automatisera din byggprocess direkt från dina GitHub-lagringsplatser. Det första steget i att använda GitHub Actions är alltså att skapa eller öppna en GitHub-lagringsplats som innehåller programkoden. Den här artikeln förutsätter att du har skapat en GitHub-lagringsplats som innehåller det Blink-program som genereras i självstudiekursen: Skapa ett program på hög nivå och att projektet heter Blink. Som med alla kontinuerliga integrationsprojekt bör du se till att ditt projekt bygger lokalt och tillhandahåller de förväntade artefakterna innan du försöker automatisera processen. I det här exemplet förutsätter vi att katalogen innehåller en Blink.imagepackage-fil efter en lyckad version out .

Skapa en katalog med namnet .devcontainer i katalogen på den översta nivån i GitHub-databasen och skapa en fil med namnet Dockerfile i katalogen med följande innehåll:

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

Den första FROM raden anger standardavbildningen av Azure Sphere Docker som basutvecklingsbehållare och den andra anger att basbehållaren ska användas som byggmiljö. Raden COPY kopierar innehållet i lagringsplatsen till behållarens /src/-katalog. Den WORKDIR anger byggkatalogen. Kommandot RUN tillhandahåller kommandot CMake för att generera byggfilerna. ENTRYPOINT Slutligen anges att ninja ska anropas för att faktiskt skapa programmet.

I databasens toppnivåkatalog skapar du katalogen .github/workflows och lägger till en fil med namnet ci.yml med följande innehåll:

# 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

Det här arbetsflödet har bara ett jobb – att skapa programmet. jobbet körs på en GitHub Actions löpare, i det här fallet ubuntu-latestoch har fyra steg:

  1. Steg 1, Checkoutär en vanlig GitHub-åtgärd som helt enkelt checkar ut din lagringsplats till den senaste ubuntu-löparen.

  2. Steg 2 skapar avbildningen (docker build) och startar behållaren (docker run).

  3. Steg 3 kopierar utdata från behållaren till löparen.

  4. Steg 4, Publicera HL-bildpaket, publicerar det avancerade programbildpaketet som en artefakt.

Genomför de här ändringarna i huvudgrenen och välj Åtgärder. Nu bör du se en sida med etiketten "Alla arbetsflöden", med minst ett arbetsflöde igång eller slutfört. Om arbetsflödet har slutförts visas en grön bockmarkering bredvid det. Klicka på ett lyckat arbetsflöde så visas en ruta med etiketten "Artefakter" som innehåller en artefakt märkt "HL imagepackage". Ladda ned denna artefakt och packa upp filen imagepackage; kan du sedan skapa en distribution eller läsa in programmet separat på enheten.

Använda Azure Pipelines för att automatiskt skapa din behållare

Med Azure Pipelines kan du automatisera din byggprocess direkt från dina GitHub-lagringsplatser (och många andra kodrepositorier). Den här artikeln förutsätter att du redan tillhör en organisation med ett Azure DevOps-projekt och har åtkomst till Azure Pipelines. Det första steget i att använda Azure Pipelines är att skapa eller öppna en lagringsplats som innehåller programkoden. Den här artikeln förutsätter att du har skapat en GitHub-lagringsplats som innehåller det Blink-program som genereras i självstudiekursen: Skapa ett program på hög nivå.

Skapa .devcontainer-katalogen i den översta katalogen på den här databasen och skapa en Dockerfile-fil i katalogen med följande innehåll:

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

Den första FROM raden anger standardavbildningen av Azure Sphere Docker som basutvecklingsbehållare och den andra anger att basbehållaren ska användas som byggmiljö. Raden COPY kopierar innehållet i lagringsplatsen till behållarens /src/-katalog. Den WORKDIR anger byggkatalogen. Kommandot RUN tillhandahåller kommandot CMake för att generera byggfilerna. ENTRYPOINT Slutligen anges att ninja ska anropas för att faktiskt skapa programmet.

Så här skapar du pipelinen:

  1. Logga in på ditt Azure DevOps-projekt och öppna Pipelines.
  2. Välj Ny pipeline och välj sedan GitHub när du tillfrågas Var är koden? Du kan komma till en GitHub-autentiseringssida. slutför autentiseringen och fortsätt till sidan för att välja lagringsplats.
  3. Välj lagringsplats för Blink. Du kommer till en sida med namnet Konfigurera din pipeline.
  4. Välj Startpipeline. Då öppnas en fil med namnet azure-pipelines.yml i toppnivåkatalogen på lagringsplatsen med en Hello- och World-uppgift.
  5. Välj Spara och kör. Acceptera standardmeddelandet och välj Spara och kör igen. Azure-pipelines.yml-filen har sparats i GitHub-lagringsplatsen och pipelinen skapas.

Ersätt innehållet i azure-pipelines.yml-filen med följande innehåll:

# 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'

Det här arbetsflödet har bara ett jobb – att skapa programmet. jobbet körs på en Azure DevOps-agent i det här fallet ubuntu-latestoch har två steg:

  1. Steg 1 skapar avbildningen (docker build), startar behållaren (docker run) och kopierar utdata från behållaren till agenten.

  2. Steg 2, Publicera build-artefakter, publicerar programbildpaket på hög nivå som en artefakt.

Genomför de här ändringarna i huvudgrenen. Öppna Pipelines igen i Azure DevOps. Du bör se en pågående pipeline eller slutföras. Om en grön bockmarkering visades vid körningen lyckades versionen. Välj den lyckade körningen. du bör se 1 Publicerat i den relaterade kolumnen. Ladda ned denna artefakt och packa upp filen imagepackage; kan du sedan skapa en distribution eller läsa in programmet separat på enheten.

Lägga till kontinuerlig integrering i Azure Sphere-exempelprogram

GitHub Actions och Azure Pipelines är avsedda att automatisera versioner för ett enda projekt, till exempel de som laddas ned från microsoft-exempelwebbläsaren. Azure Sphere-exempel på GitHub är en samling projekt med vissa delade resurser. Om du vill använda ett av dessa exempel i kontinuerlig integrering måste du införliva alla nödvändiga delade resurser. Vanligtvis innebär det att du åtminstone skapar en HardwareDefinitions-katalog i projektets toppnivåkatalog och redigerar den CMakeLists.txt filen så att den pekar på den lokala kopian. Om du till exempel skapar ett projekt baserat på exemplet HelloWorld/HelloWorld_HighLevelApp ser katalogen på översta nivån ut så här:

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

Den CMakeLists.txt filen innehåller följande rad som pekar på den delade HardwareDefinitions-katalogen i samples-repo:

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

Om du vill att projektet ska kunna byggas kopierar du mappen HardwareDefinitions till katalogen på översta nivån och redigerar sedan den CMakeLists.txt filen så att den använder den lokala platsen:

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

Kontrollera återigen att projektet byggs lokalt innan du försöker automatisera med GitHub Actions.