Megosztás a következőn keresztül:


.NET Core-alkalmazások buildelése, tesztelése és üzembe helyezése

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Az Azure Pipeline használatával automatikusan létrehozhatja, tesztelheti és üzembe helyezheti .NET Core-projektjeit. Ez a cikk a következő feladatok elvégzését mutatja be:

Feljegyzés

A .NET-keretrendszer-projektekhez a ASP.NET-alkalmazások .NET-keretrendszer való buildeléséhez nyújt segítséget.

Előfeltételek

  • Egy GitHub-fiók, ahol adattárat hozhat létre. Hozzon létre egyet ingyen.
  • Egy Azure DevOps-gyűjtemény.
  • Folyamatokat futtathat egy saját üzemeltetésű ügynökön, amelyen telepítve van a Docker, és fut az ügynök gazdagépén.

Az első folyamat létrehozása

Most ismerkedik az Azure Pipelines szolgáltatásokkal? Ha igen, akkor javasoljuk, hogy először próbálja ki a következő szakaszt.

.NET-projekt létrehozása

Ha nem rendelkezik .NET-projekttel, hozzon létre egy újat a helyi rendszeren. Először telepítse a legújabb .NET 8.0 SDK-t .

  1. Nyisson meg egy terminálablakot.

  2. Hozzon létre egy projektkönyvtárat, és navigáljon hozzá.

  3. Hozzon létre egy új .NET 8-webalkalmazást.

    dotnet new webapp -f net8.0
    
  4. Ugyanabból a terminál munkamenetből futtassa az alkalmazást helyileg a dotnet run projektkönyvtár parancsával.

    dotnet run
    
  5. Az alkalmazás elindítása után a Ctrl-C billentyűkombinációt lenyomva állítsa le.

Git-adattár létrehozása és csatlakoztatása a GitHubhoz

  1. A projektkönyvtárból hozzon létre egy helyi Git-adattárat, és véglegesítse az alkalmazáskódot a főágban.

  2. Csatlakoztassa a helyi Git-adattárat egy GitHub-adattárhoz.

DevOps-projekt létrehozása

Jelentkezzen be az Azure Pipelinesba. A bejelentkezés után a böngésző megtekinti https://dev.azure.com/my-organization-name és megjeleníti az Azure DevOps-irányítópultot.

  1. Egy böngészőben nyissa meg a dev.azure.com , és jelentkezzen be.
  2. Válassza ki a szervezetet.
  3. Hozzon létre egy új projektet az Új projekt vagy a Projekt létrehozása lehetőség kiválasztásával, ha az első projektet hozza létre a szervezetben.
  4. Adjon meg egy projektnevet.
  5. Válassza ki a projekt láthatóságát .
  6. Válassza a Létrehozás lehetőséget.
  1. Egy böngészőben nyissa meg az Azure DevOps Servert.
  2. Válassza ki a gyűjteményt.
  3. Új projekt létrehozásához válassza az Új projekt vagy a Projekt létrehozása lehetőséget, ha az első projektet hozza létre a gyűjteményben.
  4. Adjon meg egy projektnevet.
  5. Válassza ki a projekt láthatóságát .
  6. Válassza a Létrehozás lehetőséget.
  1. Egy böngészőablakban jelentkezzen be az Azure DevOps Serverre, és válassza ki a gyűjteményt.
  2. Válassza az Új projekt lehetőséget.
  3. Adja meg a projekt nevét.
  4. Ha szeretné, adjon meg egy leírást.
  5. Válassza a Létrehozás lehetőséget.

A buildkörnyezet beállítása

A buildek saját üzemeltetésű ügynökökön futnak. Győződjön meg arról, hogy az ügynökökre telepítve van a .NET Core SDK és a futtatókörnyezet szükséges verziója. A .NET Core-projekteket a .NET Core SDK és a futtatókörnyezet használatával hozhatja létre Windows, Linux, macOS és Docker rendszeren.

A .NET SDK egy adott verzióját úgy telepítheti, hogy hozzáadja a UseDotNet@2 feladatot a folyamat YAML-fájljához, vagy hozzáadja a feladatot a folyamathoz a klasszikus szerkesztő használatával.

Példa YAML-kódrészletre:

steps:
- task: UseDotNet@2
  inputs:
    version: '8.x'

A buildek a Microsoft által üzemeltetett ügynökökön futnak. A .NET Core-projekteket a .NET Core SDK és a futtatókörnyezet használatával hozhatja létre Windows, Linux és macOS rendszeren.

Másik lehetőségként használhat saját üzemeltetésű ügynököt is. Saját üzemeltetésű ügynökkel használhat előzetes verziójú vagy privát SDK-kat, amelyeket az Azure DevOps Services hivatalosan nem támogat, és növekményes buildeket futtathat.

A folyamat létrehozása

A folyamat létrehozásához használhatja a YAML-folyamatszerkesztőt vagy a klasszikus szerkesztőt. A klasszikus szerkesztő használatához válassza a Klasszikus szerkesztő használata lehetőséget.

Új folyamat létrehozása és a forrás kiválasztása
  1. Jelentkezzen be az Azure DevOps-szervezetbe, és nyissa meg a projektet.

  2. Lépjen a Folyamatok elemre, majd válassza az Új folyamat vagy a Folyamat létrehozása lehetőséget az első folyamat létrehozásakor.

  3. Végezze el a varázsló lépéseit úgy, hogy először a GitHubot választja a forráskód helyeként.

  4. Előfordulhat, hogy a rendszer átirányítja a GitHubra a bejelentkezéshez. Ha igen, adja meg a GitHub hitelesítő adatait.

  5. Amikor megjelenik az adattárak listája, válassza ki az adattárat.

  6. Előfordulhat, hogy a Rendszer átirányítja a GitHubra az Azure Pipelines alkalmazás telepítéséhez. Ha igen, válassza a Jóváhagyás > telepítés lehetőséget.

A folyamat konfigurálása
  1. Amikor megjelenik a Konfigurálás lap, válassza a Továbbiak megjelenítése lehetőséget, és válassza ki a ASP.NET Core-folyamatsablont a listából.

  2. Vizsgálja meg az új folyamatot, hogy lássa, mit tesz a YAML.

A YAML-fájlt testreszabhatja a követelményeknek megfelelően. Megadhatja például az ügynökkészletet, vagy hozzáadhat egy feladatot a különböző .NET SDK telepítéséhez.

A folyamat mentése és futtatása
  1. Ha elkészült, válassza a Mentés és futtatás lehetőséget.

    Mentés és futtatás gomb egy új YAML-folyamatban

  2. Igény szerint szerkesztheti a véglegesítési üzenetet.

  3. Véglegesítse az új azure-pipelines.yml fájlt az adattárban a Mentés és futtatás gombra kattintva.

  4. A folyamat működés közbeni megtekintéséhez válassza ki a feladatot a Feladatok szakaszban.

A folyamat létrehozása és futtatása

A folyamatot a YAML-folyamatszerkesztővel vagy a klasszikus szerkesztővel hozhatja létre.

  1. Nyissa meg a projektet, és válassza a Folyamatok lehetőséget.
  2. Válassza a Folyamat létrehozása vagy Az új folyamat létrehozása lehetőséget, ha a projekt első folyamatát hozza létre.
Válassza ki a forrást
  1. Válassza ki a forrásadattárat. Ebben a példában használja a GitHub Enterprise Servert.

    1. Adja meg a GitHub-fiók URL-címét. Például: https://github.com/<username>.
    2. Adja meg személyes hozzáférési jogkivonatát a GitHub-fiókjához.
    3. Adjon meg egy szolgáltatáskapcsolatnevet. Például: my-github.
    4. Válassza a Létrehozás lehetőséget.
  2. Válassza ki a GitHub-adattárat.

A folyamat konfigurálása
  1. A Konfigurálás lapon válassza a Továbbiak megjelenítése lehetőséget, és válassza ki a ASP.NET Core-folyamatsablont a listából.

  2. Vizsgálja meg az új folyamatot, hogy lássa, mit tesz a YAML.

A YAML-fájlt testreszabhatja a követelményeknek megfelelően. Hozzáadhat például feladatokat egy .NET SDK telepítéséhez vagy a projekt teszteléséhez és közzétételéhez.

A folyamat mentése és futtatása
  1. Válassza a Mentés lehetőséget.

    Képernyőkép egy új YAML-folyamat Mentés és futtatás gombjáról.

  2. A folyamat YAML-fájljának az adattárba való véglegesítéséhez szükség szerint szerkessze a véglegesítési üzenetet, és válassza a Mentés lehetőséget.

  3. Válassza a Futtatás lehetőséget a folyamat futtatásához.

Ha látni szeretné a buildnaplókat a folyamat futtatásakor, válassza ki az oldal tetején található buildszámot.

  1. Válassza a Mentés és futtatás lehetőséget.

    Képernyőkép egy új YAML-folyamat Mentés és futtatás gombjáról.

  2. Ha az új azure-pipelines.yml fájlt az adattárba szeretné véglegesíteni, szükség szerint szerkessze a véglegesítési üzenetet, és válassza a Mentés és futtatás lehetőséget.

A folyamat működés közbeni megtekintéséhez válassza ki a feladatot a Feladatok szakaszban.

Most már rendelkezik egy olyan munkafolyamatpal, amely készen áll a testreszabásra! További információ a folyamat testreszabásának néhány gyakori módjáról.

Környezet létrehozása

Az Azure Pipelines saját üzemeltetésű ügynököket használ a .NET Core-projektek létrehozásához. Győződjön meg arról, hogy az ügynökökre telepítve van a .NET Core SDK és a futtatókörnyezet szükséges verziója. A .NET Core-projekteket a .NET Core SDK és a futtatókörnyezet használatával hozhatja létre Windows, Linux, macOS és Docker rendszeren.

Például egy készlet és ügynök képességeinek kiválasztása a folyamat YAML-fájljában:

Kiválaszthatja a buildelési feladat ügynökkészletét és ügynökét. Az ügynökök a képességeik alapján vannak megadva.

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse

A .NET SDK egy adott verzióját úgy telepítheti, hogy hozzáadja a UseDotNet@2 feladatot a folyamathoz. Ne feledje, hogy a fizikai rendszereken futó ügynökök esetében az SDK-k és eszközök folyamaton keresztüli telepítése megváltoztatja az ügynök gazdagépének buildkörnyezetét.

Újabb SDK telepítéséhez állítsa be performMultiLevelLookup true az alábbi kódrészletet:

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

Az Azure Pipelines használatával anélkül hozhat létre .NET Core-projekteket Windowson, Linuxon vagy macOS rendszeren, hogy infrastruktúrát kellene beállítania.

Az Ubuntu például itt van beállítva a folyamat YAML-fájljában.

pool:
  vmImage: 'ubuntu-latest' 

A képek teljes listáját és a további konfigurációs példákat a Microsoft által üzemeltetett ügynökökben találja.

Az Azure Pipelines Microsoft által üzemeltetett ügynökei a támogatott .NET Core SDK-k számos előre telepített verzióját tartalmazzák. A Microsoft által üzemeltetett ügynökök nem tartalmazzák a .NET Core SDK néhány régebbi verzióját. Ezek általában nem tartalmaznak előzetes verziókat. Ha az SDK ezen verzióira van szüksége a Microsoft által üzemeltetett ügynökökön, telepítse őket a UseDotNet@2 feladattal.

Az 5.0.x SDK telepítéséhez például adja hozzá a következő kódrészletet:

steps:
- task: UseDotNet@2
  inputs:
    version: '5.x'

A Windows-ügynökök már tartalmaznak .NET Core-futtatókörnyezetet. Újabb SDK telepítéséhez állítsa be performMultiLevelLookup true az alábbi kódrészletet:

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

Tipp.

Az eszköztelepítő futtatásának költségeinek megtakarításához beállíthat linuxos, macOS vagy Windows rendszerű saját üzemeltetésű ügynököt. A saját üzemeltetésű ügynökökkel további időt takaríthat meg, ha nagy tárházzal rendelkezik, vagy növekményes buildeket futtat. A saját üzemeltetésű ügynökök is segíthetnek az Előzetes verzióban vagy a privát SDK-k használatában, amelyeket az Azure DevOps hivatalosan nem támogat, vagy amelyek csak a vállalati vagy helyszíni környezetekben érhetők el.

Függőségek helyreállítása

A NuGet egy népszerű módja annak, hogy a nem buildelt kódtól függjön. A projektfájlban megadott NuGet-csomagokat és projektspecifikus eszközöket úgy töltheti le, hogy a dotnet restore parancsot a .NET Core-feladaton keresztül vagy közvetlenül a folyamat egy szkriptjében futtatja. További információ: .NET Core-feladat (DotNetCoreCLI@2).

NuGet-csomagokat az Azure Artifactsből, NuGet.org vagy más külső vagy belső NuGet-adattárból tölthet le. A .NET Core-feladat különösen hasznos a hitelesített NuGet-hírcsatornákból származó csomagok visszaállításához. Ha a hírcsatorna ugyanabban a projektben van, mint a folyamat, nem kell hitelesítenie magát.

Ez a folyamat egy Azure Artifact-hírcsatornát dotnet restore használ a DotNetCoreCLI@2 feladathoz.

trigger:
- main

pool:
  vmImage: 'windows-latest'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    feedsToUse: 'select'
    vstsFeed: 'my-vsts-feed' # A series of numbers and letters

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

A dotnet restore parancs a NuGet.exe .NET Core SDK-val együtt csomagolt csomagot használja, és csak a .NET Core-projektfájlokban .csproj megadott csomagokat tudja visszaállítani.

Ha microsoftos .NET-keretrendszer projektje is van a megoldásban, vagy a függőségek megadására használjapackage.json, a NuGet-feladat használatával állítsa vissza ezeket a függőségeket.

- task: NuGetCommand@2
  inputs:
    command: 'restore'
    restoreSolution: '**/*.sln'
    feedsToUse: 'select'

A .NET Core SDK 2.0-s és újabb verzióiban a rendszer automatikusan visszaállítja a csomagokat olyan parancsok futtatásakor, mint a dotnet build. Hitelesített hírcsatorna használata esetén azonban továbbra is a .NET Core-feladatot kell használnia a csomagok visszaállításához.

A buildek sikertelenek lehetnek a kapcsolati problémák miatt, amikor NuGet.org csomagokat állít vissza. A csomagok gyorsítótárazásához használhatja az Azure Artifactst felsőbb rétegbeli forrásokkal. A folyamat hitelesítő adatait a rendszer automatikusan használja az Azure Artifactshez való csatlakozáskor. Ezek a hitelesítő adatok általában a Project Collection Build Service-fiókból származnak. A NuGet-csomagok gyorsítótárazásához az Azure Artifacts használatával kapcsolatos további információkért lásd : Csatlakozás az Azure Artifact-hírcsatornákhoz.

NuGet-adattár megadásához helyezze az URL-címet egy NuGet.config fájlba az adattárban. Ha a hírcsatorna hitelesítve van, kezelje a hitelesítő adatait egy NuGet-szolgáltatáskapcsolat létrehozásával a Szolgáltatások lapon, a Projektbeállítások területen.

A Microsoft által üzemeltetett ügynökök használatakor minden egyes build futtatásakor új gépet kap, amely minden futtatáskor visszaállítja a csomagokat. A helyreállítás jelentős időt vehet igénybe. A probléma elhárításához használhatja az Azure Artifactst vagy egy saját üzemeltetésű ügynököt a csomaggyorsítótár használatával.

További információ a NuGet-szolgáltatáskapcsolatokról: közzététel a NuGet-hírcsatornákban.

Csomagok visszaállítása külső hírcsatornából

Végezze el az alábbi lépéseket a csomagok külső hírcsatornából való visszaállításához.

A visszaállítási parancsot a YAML-folyamatszerkesztővel is hozzáadhatja a folyamathoz úgy, hogy közvetlenül beszúrja a következő kódrészletet a azure-pipelines.yml fájlba, vagy a feladat-asszisztens használatával adja hozzá a .NET Core-feladatot .

# do this before your build tasks
steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: config
    nugetConfigPath: NuGet.config    # Relative to root of the repository
    externalFeedCredentials: <Name of the NuGet service connection>

Cserélje le a <helyőrzőt> a szolgáltatáskapcsolat nevére.

A feladat-asszisztens használata:

Ha buildfeladatot szeretne hozzáadni a feladatkezelővel, hajtsa végre a következő lépéseket:

  1. Lépjen arra a pozícióra a YAML-fájlban, ahová be szeretné szúrni a feladatot.

  2. Válassza ki a .NET Core-t a feladatkatalógusból.

  3. Válassza ki a visszaállítási parancsot a Parancs legördülő listából.

  4. A Projekt(ek) elérési útja mezőben adja meg a .csproj fájlok elérési útját.

  5. Válassza a Hozzáadás lehetőséget.

  6. A módosítás véglegesítéséhez válassza a Mentés lehetőséget.

Feljegyzés

Győződjön meg arról, hogy az egyéni hírcsatorna meg van adva a NuGet.config fájlban, és hogy a hitelesítő adatok meg vannak adva a NuGet szolgáltatáskapcsolatban.

A projekt felépítése

A parancs futtatásával hozza létre a .NET Core-projekteket dotnet build . A parancsot parancssori szkriptként vagy .NET Core-feladatként is hozzáadhatja a folyamathoz.

.NET Core-build a .NET Core-feladattal

YAML-példa a DotNetCoreCLI@2 feladat használatával történő buildeléshez:

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)' # Update this to match your needs

A YAML-folyamatszerkesztővel buildelési feladatokat adhat hozzá a fájl közvetlen szerkesztésével vagy a .NET Core-feladat hozzáadásával a feladatsegéd használatával.

Ha buildfeladatot szeretne hozzáadni a feladatkezelővel, hajtsa végre a következő lépéseket:

  1. Lépjen arra a pozícióra a YAML-fájlban, ahová be szeretné szúrni a feladatot.

  2. Válassza ki a .NET Core-t a feladatkatalógusból.

  3. Válassza ki a build parancsot a Parancs legördülő listából.

  4. A Projekt(ek) elérési útja mezőben adja meg a .csproj fájlok elérési útját.

  5. Válassza a Hozzáadás lehetőséget.

  6. A módosítás véglegesítéséhez válassza a Mentés lehetőséget.

.NET Core-build parancssori szkripttel

YAML-példa szkriptként való buildeléshez dotnet build :

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

A YAML-folyamatszerkesztővel közvetlenül szerkesztheti a fájlt, vagy hozzáadhatja a parancssori feladatot.

A parancssori feladat hozzáadásához kövesse az alábbi lépéseket:

  1. Lépjen arra a pozícióra a YAML-fájlban, ahová be szeretné szúrni a feladatot.

  2. Válassza ki a parancssort a feladatkatalógusból.

  3. Tetszés szerint adjon hozzá egy megjelenítendő nevet.

  4. Adja meg a dotnet build parancsot paraméterekkel. Például: dotnet build --configuration $(buildConfiguration).

  5. Adja meg a .csproj fájl elérési útját munkakönyvtárként.

  6. Válassza a Hozzáadás lehetőséget.

  7. A módosítás véglegesítéséhez válassza a Mentés lehetőséget.

.NET SDK-parancsok hozzáadása a folyamathoz

A .NET SDK-parancsokat parancsfájlként vagy .NET Core-feladatként is hozzáadhatja a projekthez. A .NET Core-tevékenység (DotNetCoreCLI@2) segítségével egyszerűen adhat hozzá dotnet CLI-parancsokat a folyamathoz. .NET Core-feladatokat a YAML-fájl szerkesztésével vagy a klasszikus szerkesztővel vehet fel.

.NET CLI-parancs hozzáadása a .NET Core-feladattal

Ha .NET Core CLI-parancsot szeretne hozzáadni a YAML-folyamatszerkesztővel, hajtsa végre a következő lépéseket:

  1. Lépjen arra a pozícióra a YAML-fájlban, ahová be szeretné szúrni a feladatot.

  2. Válassza ki a .NET Core-t a feladatkatalógusból.

  3. Válassza ki a futtatni kívánt parancsot.

  4. Konfigurálja a szükséges beállításokat.

  5. Válassza a Hozzáadás lehetőséget.

  6. A módosítás véglegesítéséhez válassza a Mentés lehetőséget.

.NET Core CLI-parancs hozzáadása szkripttel

A fájlban azure-pipelines.yml .NET Core CLI-parancsokat script is hozzáadhat.

Példa:


steps:
# ...
- script: dotnet test <test-project> 

Eszköz telepítése

Ha windowsos buildben szeretne telepíteni egy .NET Core-alapú globális eszközt, például a dotnetsay-t , hajtsa végre a következő lépéseket:

  1. Adja hozzá a .NET Core-feladatot , és állítsa be a következő tulajdonságokat:
    • Parancs: egyéni.
      • A projektek elérési útja: hagyja üresen.
    • Egyéni parancs: eszköz.
    • Argumentumok: install -g dotnetsay.
  2. Az eszköz futtatásához adjon hozzá egy parancssort, és állítsa be a következő tulajdonságokat:
    • Szkript: dotnetsay.

A tesztek futtatása

Ha tesztprojektek vannak az adattárban, a .NET Core-feladattal egységteszteket futtathat olyan tesztelési keretrendszerek használatával, mint az MSTest, az xUnit és az NUnit. A tesztprojektnek a Microsoft.NET.Test.SDK 15.8.0-s vagy újabb verziójára kell hivatkoznia. A teszteredmények automatikusan közzé lesznek téve a szolgáltatásban. Ezek az eredmények a build összegzésében érhetők el, és a sikertelen tesztek és a tesztelés időzítésének elemzéséhez használhatók.

A folyamathoz a DotNetCoreCLI@2 feladattal adhat hozzá tesztfeladatot, vagy hozzáadhatja a következő kódrészletet a azure-pipelines.yml fájlhoz:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

A .NET Core feladatszerkesztő használatakor állítsa be a Command to test (Tesztelés) parancsot, és a Projektek elérési útja parancsnak a megoldás tesztprojektjéhez kell hivatkoznia.

Másik lehetőségként futtathatja a dotnet test parancsot egy adott naplózóval, majd használhatja a Teszteredmények közzététele feladatot:

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx
- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Kódlefedettség gyűjtése

Amikor a Windows platformra épít, a kódlefedettségi metrikákat a beépített lefedettségi adatgyűjtővel gyűjtheti össze. A tesztprojektnek a Microsoft.NET.Test.SDK 15.8.0-s vagy újabb verziójára kell hivatkoznia.

Amikor a .NET Core-feladatot használja a tesztek futtatására, a rendszer automatikusan közzéteszi a lefedettségi adatokat a kiszolgálón. A .coverage fájl a Visual Studióban való megtekintéshez letölthető a build összegzéséből.

Adja hozzá a következő kódrészletet a azure-pipelines.yml fájlhoz:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration) --collect "Code coverage"'

A .NET Core-feladat hozzáadása a feladatszerkesztőn keresztül:

  1. Adja hozzá a .NET Core-feladatot a buildelési feladathoz, és állítsa be a következő tulajdonságokat:

    1. Parancs: teszt.
    2. A projektek elérési útja: A megoldásban szereplő tesztprojektekre kell hivatkoznia.
    3. Argumentumok: --configuration $(BuildConfiguration) --collect "Code coverage".
  2. Győződjön meg arról, hogy a Teszteredmények közzététele lehetőség továbbra is be van jelölve.

Ha a dotnet test parancs futtatását választja, adja meg a teszteredmény-naplózót és a lefedettségi beállításokat. Ezután használja a Teszteredmények közzététele feladatot:

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx --collect "Code coverage"
- task: PublishTestResults@2
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Kódlefedettségi metrikák gyűjtése a Coverlet használatával

Ha Linuxra vagy macOS-re készül, a Coverlet vagy egy hasonló eszköz használatával kódlefedettségi metrikákat gyűjthet.

A kódlefedettségi eredményeket közzéteheti a kiszolgálón a Kódlefedettségi eredmények közzététele (PublishCodeCoverageResults@1) feladattal. A lefedettségi eszközt úgy kell konfigurálni, hogy cobertura vagy JaCoCo lefedettségi formátumban hozzon létre eredményeket.

Tesztek futtatásához és kódlefedettség közzétételéhez a Coverlettel végezze el a következő feladatokat:

  • Adjon hozzá egy hivatkozást a coverlet.collector NuGet-csomaghoz.

  • Adja hozzá a következő kódrészletet a azure-pipelines.yml fájlhoz:

    - task: UseDotNet@2
      inputs:
        version: '8.x'
        includePreviewVersions: true # Required for preview versions
    
    - task: DotNetCoreCLI@2
      displayName: 'dotnet build'
      inputs:
        command: 'build'
        configuration: $(buildConfiguration)
    
    - task: DotNetCoreCLI@2
      displayName: 'dotnet test'
      inputs:
        command: 'test'
        arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura'
        publishTestResults: true
        projects: 'MyTestLibrary' # update with your test project directory
    
    - task: PublishCodeCoverageResults@1
      displayName: 'Publish code coverage report'
      inputs:
        codeCoverageTool: 'Cobertura'
        summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
    

A kód csomagolása és kézbesítése

A buildösszetevőket a következőkkel teheti közzé:

  • Közzététel az Azure Pipelinesban.
  • Csomagok közzététele az Azure Artifactsben.
  • NuGet-csomag létrehozása és közzététele a NuGet-hírcsatornában.
  • .zip archívum létrehozása a webalkalmazás üzembe helyezéséhez.

Összetevők közzététele az Azure Pipelinesban

A .NET-build kimenetének a folyamaton való közzétételéhez hajtsa végre a következő feladatokat:

  • Futtassa dotnet publish --output $(Build.ArtifactStagingDirectory) a .NET parancssori felületét, vagy adja hozzá a DotNetCoreCLI@2 feladatot a közzétételi paranccsal.
  • Tegye közzé az összetevőt a Folyamatösszetevő közzététele feladattal.

Adja hozzá a következő kódrészletet a azure-pipelines.yml fájlhoz:

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

Feljegyzés

A DotNetCoreCLI@2 tevékenység publishWebProjects alapértelmezés szerint igaz értékre van állítva. Ez a feladat alapértelmezés szerint minden webes projektet közzétesz az adattárban. További segítséget és információt a GitHub nyílt forráskód feladatában talál.

Ha a közzététel előtt további fájlokat szeretne másolni a buildkönyvtárba, használja a Fájlok másolása (CopyFile@2) feladatot.

A .NET-build kimenetének a folyamaton való közzétételéhez hajtsa végre a következő feladatokat:

  • Futtassa dotnet publish --output $(Build.ArtifactStagingDirectory) a parancssori felületet, vagy adja hozzá a DotNetCoreCLI@2 feladatot a közzétételi paranccsal.
  • Tegye közzé az összetevőt a buildösszetevő (PublishBuildArtifacts@1) közzétételével.

Adja hozzá a következő kódrészletet a azure-pipelines.yml fájlhoz a buildösszetevők .zip fájlként való közzétételéhez:

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishBuildArtifacts@1
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

További információ: Buildösszetevők közzététele és letöltése.

Közzététel NuGet-hírcsatornában

NuGet-csomag létrehozásához és a NuGet-hírcsatornában való közzétételéhez adja hozzá a következő kódrészletet:

steps:
# ...
# do this near the end of your pipeline in most cases
- script: dotnet pack /p:PackageVersion=$(version)  # define version variable elsewhere in your pipeline
- task: NuGetAuthenticate@1
  inputs:
    nuGetServiceConnections: '<Name of the NuGet service connection>'
- task: NuGetCommand@2
  inputs:
    command: push
    nuGetFeedType: external
    publishFeedCredentials: '<Name of the NuGet service connection>'
    versioningScheme: byEnvVar
    versionEnvVar: version

Feljegyzés

A NuGetAuthenticate@1 feladat nem támogatja a NuGet API-kulcsok hitelesítését. Ha NuGet API-kulcsot használ, használja a NuGetCommand@2 feladatot az command --api-key argumentummal megadott bemeneti beállítással push . Például: dotnet nuget push --api-key $(NuGetApiKey).

A NuGet-csomagok verziószámozásával és közzétételével kapcsolatos további információkért tekintse meg a NuGet-hírcsatornákban való közzétételt.

NuGet-csomag közzététele az Azure Artifactsben

NuGet-csomagjait közzéteheti az Azure Artifacts-csatornán a NuGetCommand@2 használatával az Azure Artifact-hírcsatornába való leküldéshez. Lásd például a NuGet-csomagok közzétételét az Azure Pipelines használatával.

Webalkalmazás üzembe helyezése

Ha olyan .zip fájlarchívumot szeretne létrehozni, amely készen áll a webalkalmazásban való közzétételre, adja hozzá a következő kódrészletet:

steps:
# ...
# do this after you've built your app, near the end of your pipeline in most cases
# for example, you do this before you deploy to an Azure web app on Windows
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

Az archívum webalkalmazásban való közzétételéhez tekintse meg az Azure Web Apps üzembe helyezését.

Rendszerkép létrehozása és leküldés a tárolóregisztrációs adatbázisba

Létrehozhat egy lemezképet az alkalmazáshoz, és leküldheti egy tárolóregisztrációs adatbázisba.

Szimbólumok közzététele

A PublishSymbols@2 feladat használatával szimbólumokat tehet közzé egy Azure Artifacts szimbólumkiszolgálón vagy fájlmegosztáson.

Ha például szimbólumokat szeretne közzétenni egy fájlmegosztásban, adja hozzá a következő kódrészletet a azure-pipelines.yml fájlhoz:

- task: PublishSymbols@2
  inputs:
    SymbolsFolder: '$(Build.SourcesDirectory)'
    SearchPattern: '**/bin/**/*.pdb'
    IndexSources: true
    PublishSymbols: true
    SymbolServerType: 'FileShare' 
    SymbolsPath: '\\server\shareName'

A klasszikus szerkesztő használata esetén válassza az Indexforrás-közzétételi szimbólumokat a feladatkatalógusból a folyamathoz való hozzáadáshoz.

További információ: Szimbólumok közzététele.

Hibaelhárítás

Ha létrehozhatja a projektet a fejlesztői gépén, de problémákat tapasztal az Azure Pipelineson való létrehozás során, vizsgálja meg az alábbi lehetséges okokat és korrekciós műveleteket:

  • A .NET Core SDK előzetes verziói nincsenek telepítve a Microsoft által üzemeltetett ügynökökre. A .NET Core SDK új verziójának kiadása után néhány hétbe telhet az összes Azure Pipelines-adatközpont üzembe helyezése. Nem kell megvárnia, amíg a bevezetés befejeződik. A .NET Core használata feladat használatával telepítheti a Microsoft által üzemeltetett ügynökökre a kívánt .NET Core SDK-verziót.
  • Ellenőrizze a fejlesztőgép .NET Core SDK-verzióit és futtatókörnyezetét, és győződjön meg arról, hogy azok megfelelnek az ügynöknek. A .NET Core SDK verziójának nyomtatásához parancssori szkriptet dotnet --version is hozzáadhat a folyamathoz. A .NET Core Tool Installer használatával telepítse ugyanazt a verziót az ügynökön, vagy frissítse projektjeit és fejlesztői gépét a .NET Core SDK újabb verziójára.

  • Előfordulhat, hogy olyan logikát használ a Visual Studio IDE-ben, amely nincs kódolva a folyamatban. Az Azure Pipelines egy új folyamat során egymás után futtatja a feladatokban megadott parancsokat. Vizsgálja meg a folyamat buildjének naplóit, és tekintse meg a build részeként futtatott parancsokat. Ismételje meg ugyanazokat a parancsokat ugyanabban a sorrendben a fejlesztőgépen a probléma megkereséséhez.

  • Ha vegyes megoldással rendelkezik, amely tartalmaz néhány .NET Core-projektet és néhány .NET-keretrendszer-projektet, a NuGet-feladat használatával is visszaállíthatja a fájlokban packages.config megadott csomagokat. Adja hozzá az MSBuild vagy a Visual Studio buildelési feladatát a .NET-keretrendszer projektek létrehozásához.

  • Előfordulhat, hogy a buildek időnként meghiúsulnak a csomagok visszaállítása során: NuGet.org problémákat tapasztal, vagy hálózati problémák merülnek fel az Azure-adatközpont és a NuGet.org között. Megtudhatja, hogy az Azure Artifacts és a NuGet.org felsőbb rétegbeli forrásként való használata javítja-e a buildek megbízhatóságát, mivel ez nem a mi irányításunk alatt áll.

  • Időnként előfordulhat, hogy a .NET Core SDK vagy a Visual Studio új verziójának bevezetésekor a build megszakadhat. A NuGet-eszköz egy újabb verziója vagy funkciója például az SDK-val együtt szállítva megszakíthatja a buildet. A probléma elkülönítéséhez a .NET Core Eszköztelepítő feladatával adja meg a buildben használt .NET Core SDK verzióját.

GYIK

K: Hol tudhatok meg többet az Azure Artifactsről?

Válasz: Csomagkezelés az Azure Artifactsben

K: Hol tudhatok meg többet a .NET Core-parancsokról?

Válasz: .NET Core CLI-eszközök

K: Hol tudhatok meg többet a tesztek megoldásban való futtatásáról?

Válasz: Egységtesztelés .NET Core-projektekben

K: Hol tudhatok meg többet a feladatokról?

Válasz: Buildelési és kiadási feladatok