CI/CD dla .NET: GitHub Actions vs Azure DevOps - Pełne Porównanie 2025

Architektura i podstawowe koncepcje

GitHub Actions używa czterowarstwowej architektury: Events (triggery),Workflows (pliki .yml), Jobs (jednostki równoległego wykonania), i Steps (pojedyncze zadania). Workflow'y znajdują się w repozytorium w.github/workflows/.

Architektura i serwisy

Azure DevOps oferuje pięć zintegrowanych serwisów, które działają razem lub niezależnie:

Strategia migracji

1. Faza inwentaryzacji: Udokumentuj wszystkie pipeline'y, triggery, service connections, variable groups i deployment targets w Azure DevOps
2. Pilotażowy pipeline: Wybierz niekrytyczną aplikację i zmigruj jej pipeline jako pierwszą. Uruchom oba pipeline'y równolegle przez 1-2 tygodnie do walidacji
3. Sekrety i zmienne: Zmigruj sekrety do GitHub Secrets, zmienne do GitHub Environment Variables. Użyj Dependabot do automatycznej rotacji sekretów
4. Service Connections: Zamień Azure DevOps service connections na GitHub OIDC (OpenID Connect) dla passwordless authentication do Azure
5. Migracja wsadowa: Migruj pozostałe pipeline'y partiami, grupując po zespole lub serwisie. Utrzymuj Azure DevOps jako backup przez 30 dni
6. Decommission: Po okresie walidacji, wyłącz Azure DevOps pipelines. Zachowaj Boards/Test Plans jeśli potrzebne

Częste konwersje wzorców

trigger:
  branches:
    include:
      - main
      - develop

on:
  push:
    branches:
      - main
      - develop

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'

env:
  BUILD_CONFIGURATION: 'Release'
  DOTNET_VERSION: '8.0.x'

- task: UseDotNet@2
  inputs:
    version: '8.0.x'
- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    projects: '**/*.csproj'

- uses: actions/setup-dotnet@v4
  with:
    dotnet-version: '8.0.x'
- run: dotnet build --configuration Release

GitHub Actions: .NET 8 Web API na Azure App Service

Plik: .github/workflows/deploy-api.yml

name: Deploy .NET API to Azure

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  workflow_dispatch:

env:
  DOTNET_VERSION: '8.0.x'
  AZURE_WEBAPP_NAME: 'my-api-prod'
  WORKING_DIRECTORY: './src/MyApi'

permissions:
  id-token: write  # Required for OIDC
  contents: read

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Setup .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: Restore dependencies
      run: dotnet restore
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Build
      run: dotnet build --no-restore --configuration Release
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Run unit tests
      run: dotnet test --no-build --configuration Release --logger "trx" --collect:"XPlat Code Coverage"
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Publish
      run: dotnet publish --no-build --configuration Release --output ./publish
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Upload artifact
      uses: actions/upload-artifact@v4
      with:
        name: api-package
        path: ${{ env.WORKING_DIRECTORY }}/publish
        retention-days: 7

  deploy-production:
    needs: build-and-test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    environment:
      name: production
      url: https://my-api-prod.azurewebsites.net

    steps:
    - name: Download artifact
      uses: actions/download-artifact@v4
      with:
        name: api-package
        path: ./publish

    - name: Azure Login (OIDC)
      uses: azure/login@v2
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Deploy to Azure Web App
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ./publish

    - name: Health Check
      run: |
        sleep 30  # Wait for app to start
        response=$(curl -s -o /dev/null -w "%{http_code}" https://my-api-prod.azurewebsites.net/health)
        if [ $response -ne 200 ]; then
          echo "Health check failed with status $response"
          exit 1
        fi
        echo "Deployment successful, health check passed"

Kluczowe funkcje: Oddzielne joby build/deploy, cachowanie artifacts, autentykacja OIDC (bez sekretów!), environment protection rules, walidacja health check.

Azure DevOps: .NET 8 Web API na Azure App Service

Plik: azure-pipelines.yml

trigger:
  branches:
    include:
      - main

pr:
  branches:
    include:
      - main

variables:
  dotnetVersion: '8.0.x'
  buildConfiguration: 'Release'
  azureSubscription: 'MyAzureServiceConnection'
  webAppName: 'my-api-prod'
  workingDirectory: './src/MyApi'

stages:
- stage: Build
  displayName: 'Build and Test'
  jobs:
  - job: BuildJob
    displayName: 'Build .NET API'
    pool:
      vmImage: 'ubuntu-latest'

    steps:
    - task: UseDotNet@2
      displayName: 'Install .NET SDK'
      inputs:
        version: $(dotnetVersion)
        packageType: 'sdk'

    - task: DotNetCoreCLI@2
      displayName: 'Restore NuGet packages'
      inputs:
        command: 'restore'
        projects: '$(workingDirectory)/**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Build solution'
      inputs:
        command: 'build'
        projects: '$(workingDirectory)/**/*.csproj'
        arguments: '--configuration $(buildConfiguration) --no-restore'

    - task: DotNetCoreCLI@2
      displayName: 'Run unit tests'
      inputs:
        command: 'test'
        projects: '$(workingDirectory)/**/*Tests.csproj'
        arguments: '--configuration $(buildConfiguration) --no-build --collect:"XPlat Code Coverage"'

    - task: DotNetCoreCLI@2
      displayName: 'Publish application'
      inputs:
        command: 'publish'
        publishWebProjects: false
        projects: '$(workingDirectory)/MyApi.csproj'
        arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
        zipAfterPublish: true

    - task: PublishBuildArtifacts@1
      displayName: 'Publish artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'api-package'

- stage: Deploy
  displayName: 'Deploy to Production'
  dependsOn: Build
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployWeb
    displayName: 'Deploy to Azure App Service'
    pool:
      vmImage: 'ubuntu-latest'
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: DownloadBuildArtifacts@1
            displayName: 'Download artifacts'
            inputs:
              buildType: 'current'
              downloadType: 'single'
              artifactName: 'api-package'
              downloadPath: '$(System.ArtifactsDirectory)'

          - task: AzureWebApp@1
            displayName: 'Deploy to Azure Web App'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: '$(webAppName)'
              package: '$(System.ArtifactsDirectory)/api-package/*.zip'
              deploymentMethod: 'zipDeploy'

          - task: AzureCLI@2
            displayName: 'Health check'
            inputs:
              azureSubscription: '$(azureSubscription)'
              scriptType: 'bash'
              scriptLocation: 'inlineScript'
              inlineScript: |
                sleep 30
                response=$(curl -s -o /dev/null -w "%{http_code}" https://my-api-prod.azurewebsites.net/health)
                if [ $response -ne 200 ]; then
                  echo "Health check failed with status $response"
                  exit 1
                fi
                echo "Deployment successful, health check passed"

Kluczowe funkcje: Wieloetapowy pipeline (separacja build/deploy), deployment job ze śledzeniem environment, service connection dla Azure, zarządzanie artifacts, walidacja health check.

Profil aplikacji

• Typ: Backend API e-commerce (.NET 8, ASP.NET Core Minimal APIs)
• Infrastruktura: Azure App Service (3 instancje, tier P2v3)
• Baza danych: Azure SQL Database (tier S3)
• Zespół: 8 developerów, ~40 commitów/dzień, 15-20 deploymentów/dzień
• Testowanie: 1,200 testów jednostkowych, 150 testów integracyjnych