.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:

• Állítsa be a buildkörnyezetet a Microsoft által üzemeltetett vagy saját üzemeltetésű ügynökökkel.
• Állítsa vissza a függőségeket, hozza létre a projektet, és tesztelje a .NET Core-feladatot (DotNetCoreCLI@2) vagy egy szkriptet.
• Tesztelje a kódot, és a kódlefedettségi feladat használatával tegye közzé a kódlefedettségi eredményeket.
• Csomagolja és kézbesítse a build kimenetét a következőre:
  • a folyamathoz.
  • NuGet-hírcsatorna.
  • egy .zip webalkalmazás Azure-ban való üzembe helyezéséhez szükséges fájl.

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-szervezet és -projekt. Hozzon létre egyet ingyen.
• Folyamatok futtatásának lehetősége a Microsoft által üzemeltetett ügynökökön. Vásárolhat párhuzamos feladatot , vagy ingyenes szintet kérhet.

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. Csatlakozás a helyi Git-adattárat egy GitHub-adattárba.

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.

A buildkörnyezet beállítása

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.

YAML

Ú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.

   

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.

Klasszikus

Ezekkel a lépésekkel hozhatja létre a folyamatot a klasszikus szerkesztővel.

Folyamat létrehozása

1. Nyissa meg a projektet, és válassza a Folyamatok lehetőséget.

2. Ha nem a projekt első folyamatát hozza létre, válassza a Folyamat létrehozása vagy az Új folyamat létrehozása lehetőséget.

3. Válassza a Klasszikus szerkesztő használata lehetőséget.

Válassza ki a forrást

1. Válassza ki a forrást. Ebben a példában válassza a GitHubot.
2. Adja meg a GitHub-hitelesítő adatait a folyamatban használni kívánt GitHub-szolgáltatáskapcsolat létrehozásához.
3. Válassza ki az adattárat, és válassza a Folytatás lehetőséget.

A folyamat konfigurálása

1. A Sablon kiválasztása területen keresse meg és válassza ki a ASP.NET Core-t.

   Megnyílik a folyamatlap, ahol konfigurálhatja a folyamatot. Itt hozzáadhat tevékenységeket, megadhatja az ügynökkészleteket és az ügynököket, és konfigurálhat más buildelési beállításokat.

2. A Feladatok lapon válassza ki az ügynökkészletet(általában alapértelmezett)

3. Válassza ki az ügynök specifikációját. Ebben a példában válassza a Windows legújabb parancsát.

   Az ügynökfeladathoz más tevékenységeket is hozzáadhat, ha kiválasztja + az ügynökfeladatot, és kiválaszt egy másik feladatot a katalógusból. Előfordulhat például, hogy a .NET SDK szükséges verziójának telepítéséhez első feladatként a .NET Core használata feladatot szeretné hozzáadni.

A folyamat mentése és futtatása

1. Válassza a Mentés és üzenetsor lehetőséget a Lap tetején található Mentés és üzenetsor legördülő listából.
2. A Futtatás folyamatban írjon be egy megjegyzést, és válassza a Mentés és futtatás lehetőséget.

A folyamat működés közben is látható, ha kiválasztja a feladatot az Összegzés lap Feladatok szakaszából.

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 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 performMultiLevelLookuptrue 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 Windowsrendszerű 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. Ha többet szeretne megtudni arról, hogyan használhatja az Azure Artifactst a NuGet-csomagok gyorsítótárazásához, tekintse meg Csatlakozás Azure Artifact-hírcsatornákba.

NuGet-adattár megadásához helyezze az URL-címet egy NuGet.config fájlba az adattárban. Ha a hírcsatorna hitelesítése megtörtént, kezelje a hitelesítő adatait egy NuGet-szolgáltatáskapcsolat létrehozásával a Project Gépház Szolgáltatások lapján.

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.

YAML

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.

Klasszikus

A klasszikus szerkesztővel az alábbi lépésekkel adhat hozzá visszaállítási feladatot:

1. Válassza ki a folyamat tevékenységeit , és válassza ki a buildelési feladatokat futtató feladatot.

2. Válassza ki + , ha új feladatot szeretne hozzáadni a feladathoz.

3. A feladatkatalógusban keresse meg és válassza a .NET Core-feladatot , majd válassza a Hozzáadás lehetőséget.

4. Válassza ki a feladatot a feladatszerkesztő megnyitásához.

5. Válassza a visszaállítást a Parancslistában , és adja meg a feladathoz szükséges egyéb beállításokat.

6. A feladatlistában húzza a feladatot a buildelési tevékenység elé.

7. A Mentés > üzenetsor legördülő listájában válasszon egy lehetőséget a módosítás mentéséhez.

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

YAML

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.

Klasszikus

Ha buildelési feladatot szeretne hozzáadni a klasszikus szerkesztővel, hajtsa végre a következő lépéseket:

1. Válassza ki a folyamatok tevékenységeit .

2. Válassza ki a buildelési feladatokat futtató feladatot.

3. Válassza ki + , ha új feladatot szeretne hozzáadni a feladathoz.

4. A feladatkatalógusban keresse meg és adja hozzá a .NET Core-feladatot .

5. Válassza ki a feladatot, és válassza a Build lehetőséget a Command legördülő listából.

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

7. Húzza a feladatot a folyamat megfelelő feladatütemezéséhez.

8. Válassza a Mentés és üzenetsor legördülő listát, és válasszon egy lehetőséget a módosítások mentéséhez.

.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)'

YAML

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.

Klasszikus

Ha buildelési feladatot szeretne hozzáadni a klasszikus szerkesztővel, hajtsa végre a következő lépéseket:

1. Válassza ki a folyamatok tevékenységeit .

2. Válassza ki a buildelési feladatokat futtató feladatot.

3. Válassza ki + , ha új feladatot szeretne hozzáadni a feladathoz.

4. A feladatkatalógusban keresse meg és adja hozzá a parancssori feladatot.

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

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

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

8. Húzza a feladatot a folyamat megfelelő feladatütemezéséhez.

9. Válassza a Mentés és üzenetsor legördülő listát, és válasszon egy lehetőséget a módosítások mentéséhez.

.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

YAML

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.

Klasszikus

A .NET Core-feladat klasszikus szerkesztővel való hozzáadásához hajtsa végre a következő lépéseket:

1. Válassza ki a folyamatok tevékenységeit .

2. Válassza ki a buildelési feladatokat futtató feladatot.

3. Válassza ki + , ha új feladatot szeretne hozzáadni a feladathoz.

4. A feladatkatalógusban keresse meg és adja hozzá a .NET Core-feladatot .

5. Jelölje ki a feladatot, és válassza ki a futtatni kívánt parancsot .

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

7. Húzza a feladatot a folyamat megfelelő feladatütemezéséhez.

8. A Mentés és az üzenetsor legördülő listában válasszon egy lehetőséget a módosítások mentéséhez.

.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.

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