Guida introduttiva: Usare GitHub Actions per eseguire il push in Azure Artifacts

Servizi di Azure DevOps

Iniziare a usare GitHub Actions e Azure Artifacts insieme. GitHub Actions consente di automatizzare i flussi di lavoro dello sviluppo di software dall'interno di GitHub. È possibile usare GitHub Actions per eseguire la distribuzione in un feed di Azure Artifacts.

È possibile eseguire l'autenticazione usando un'identità gestita o un token di accesso personale . Un PAT (token di accesso personale) è un token generato dall'utente che concede l'accesso alle risorse di Azure DevOps. Un'identità gestita è un tipo di entità servizio gestita che Azure gestisce automaticamente per consentire l'autenticazione senza password tra i servizi di Azure e Azure DevOps. L'identità gestita è l'opzione di autenticazione più sicura.

Prerequisiti

Un account GitHub con un repository. Aggiungere GitHub e creare un repository.
Feed di Azure Artifacts su cui esegui il push del pacchetto NuGet da un flusso di lavoro GitHub. Introduzione ai pacchetti NuGet.
Configurare un'identità gestita assegnata dall'utente con credenziali federate associate.
- Creare un'identità gestita assegnata dall'utente.
- Copiare i valori per ID client, ID sottoscrizione e ID directory (tenant) da usare più avanti nel flusso di lavoro di GitHub Actions.
- Assegnare un ruolo appropriato all'identità gestita assegnata dall'utente.
- Configurare una credenziale di identità federata in un'identità gestita assegnata dall'utente per considerare attendibili i token emessi da GitHub Actions nel repository GitHub.
Autorizzazione per assegnare un'identità gestita al gruppo Collaboratore in Azure DevOps. Gli amministratori del progetto e gli amministratori della raccolta dispongono di questa autorizzazione.

Nota

Un approccio alternativo consiste nell'usare un'applicazione Microsoft Entra con un'entità servizio e credenziali di autenticazione federata per connettere Azure DevOps e GitHub Actions. Per altre informazioni su questo approccio, vedere Configurare un'app per considerare attendibile un provider di identità esterno.

Assegnare autorizzazioni all'identità gestita in Azure DevOps

Per assegnare l'identità gestita al team collaboratore , seguire questa procedura:

Accedere al progetto (https://dev.azure.com/{Your_Organization/Your_Project}).
Passare a Impostazioni progetto.
Selezionare Autorizzazioni generali>.
Scegliere il gruppo Collaboratori .
Selezionare la scheda Membri e quindi selezionare Aggiungi.
Cercare e trovare l'identità gestita.
Selezionare Salva per aggiungere l'identità al gruppo Collaboratori .

Creare segreti di GitHub

È necessario fornire l'ID client, l'ID tenant e l'ID sottoscrizione dell'identità gestita all'azione di accesso. Questi valori vengono archiviati nei segreti di GitHub e a cui viene fatto riferimento nel flusso di lavoro.

In GitHub, andare al proprio repository.
Passare a Impostazioni nel menu di spostamento.
Selezionare Sicurezza > Segreti e variabili > Azioni.
Selezionare Nuovo segreto repository.
Creare segreti per AZURE_CLIENT_ID, AZURE_TENANT_IDe AZURE_SUBSCRIPTION_ID. Usare questi valori dell'identità gestita per i segreti di GitHub:

Segreto GitHub Applicazione Microsoft Entra

AZURE_CLIENT_ID ID applicazione (client)

AZURE_TENANT_ID ID della directory (tenant)

AZURE_SUBSCRIPTION_ID ID sottoscrizione
Salvare ogni segreto selezionando Aggiungi segreto.

Segreto GitHub	Applicazione Microsoft Entra
AZURE_CLIENT_ID	ID applicazione (client)
AZURE_TENANT_ID	ID della directory (tenant)
AZURE_SUBSCRIPTION_ID	ID sottoscrizione

Creare un flusso di lavoro GitHub che compila un artefatto

I flussi di lavoro di GitHub sono una serie di azioni, simili alle attività in Azure Pipelines. Questo flusso di lavoro automatizza il processo di compilazione, test, creazione di pacchetti e pubblicazione di un progetto .NET in Azure Artifacts usando un'identità gestita e l'autenticazione federata. Il flusso di lavoro:

Usa l'azione azure/login per accedere ad Azure usando un'identità gestita.
Installa il provider di credenziali per Azure Artifacts.
Estrae un token di accesso usando l'interfaccia della riga di comando di Azure e configura il provider di autenticazione per l'uso del token Di Azure DevOps.
Configura un ambiente dell'interfaccia della riga di comando di .NET Core usando l'azione setup-dotnet.
Ripristina le dipendenze, compila il progetto e le relative dipendenze in un set di file binari ed esegue tutti gli unit test associati al progetto.
Inserisce il codice in un pacchetto NuGet con la variabile di ambiente GitHub Run ID inclusa nel numero di versione.
Pubblica il pacchetto NuGet in Azure Artifacts.

Creare un nuovo file YAML

Nel repository GitHub creare un nuovo file YAML nella .github/workflows directory.

Copiare il contenuto seguente nel file YAML. Personalizzare i AZURE_ARTIFACTS_FEED_URLvalori , BUILD_CONFIGURATIONe DOTNET_VERSION .

Imposta AZURE_ARTIFACTS_FEED_URL all'URL del registro per il feed di Azure Artifacts.
Impostare BUILD_CONFIGURATION.
Impostare DOTNET_VERSION sulla versione del progetto.

name: Push a NuGet package to Azure Artifacts with managed identity and federated authentication

on:
  push:
    branches:
      - main

permissions:
  id-token: write # Require write permission to Fetch an federated identity token.
  contents: read # Require read permission to access the repository contents.

env:
  AZURE_ARTIFACTS_FEED_URL: https://pkgs.dev.azure.com/myorg/nuget-artifact/_packaging/Fabrikam_Feed/nuget/v3/index.json    
  BUILD_CONFIGURATION: 'Release'    # set this to the appropriate build configuration
  DOTNET_VERSION: '6.0' 
  NuGetDirectory: ${{ github.workspace}}/nuget
  VSS_NUGET_URI_PREFIXES: https://pkgs.dev.azure.com/myorg/


jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Checkout the repo
      - uses: actions/checkout@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}

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

      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Run dotnet build and package
      - name: dotnet build and test
        run: |
          dotnet restore
          dotnet build --configuration '${{ env.BUILD_CONFIGURATION }}'
          dotnet test --configuration '${{ env.BUILD_CONFIGURATION }}'

    # Create the NuGet package in the folder from the environment variable NuGetDirectory
      - run: dotnet pack --configuration Release --output ${{ env.NuGetDirectory }}

    # Publish the NuGet package as an artifact, so they can be used in the following jobs
      - uses: actions/upload-artifact@v3
        with:
          name: nuget
          if-no-files-found: error
          retention-days: 7
          path: ${{ env.NuGetDirectory }}/*.nupkg

  az-artifacts-build-and-deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}

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

      - uses: actions/download-artifact@v3
        with:
          name: nuget
          path: ${{ env.NuGetDirectory }}

      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}
          source-url: ${{ env.AZURE_ARTIFACTS_FEED_URL }}
        env:
          NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

      - name: Install credential provider for Azure Artifacts
        run: sh -c "$(curl -fsSL https://aka.ms/install-artifacts-credprovider.sh)"

      - name: Extract access token
        run: |
            accessToken=$(az account get-access-token --query accessToken --resource 499b84ac-1321-427f-aa17-267ca6975798 -o tsv)
            echo "::add-mask::$accessToken"
            echo "ACCESS_TOKEN=$accessToken" >> $GITHUB_ENV

      - name: Configure authentication provider to use Azure DevOps token
        run: |
          echo "VSS_NUGET_ACCESSTOKEN=$ACCESS_TOKEN" >> $GITHUB_ENV

      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration '${{ env.BUILD_CONFIGURATION }}'
          dotnet pack --configuration '${{ env.BUILD_CONFIGURATION }}' --output ./nupkg --version-suffix ${{ github.run_id }}

      - name: 'Publish the package to Azure Artifacts'
        run: dotnet nuget push ${{ env.NuGetDirectory }}/*.nupkg --api-key AzureDevOps --source ${{ env.AZURE_ARTIFACTS_FEED_URL }}

Prerequisiti

Un account GitHub con un repository. Aggiungere GitHub e creare un repository.
Feed di Azure Artifacts a cui invii il pacchetto NuGet da un flusso di lavoro di GitHub. Introduzione ai pacchetti NuGet.
Token di accesso personale di Azure DevOps da usare con l'azione GitHub. Creare un token di accesso personale.
- Il token di accesso personale deve avere autorizzazioni di lettura, scrittura e gestione dei pacchetti .

Eseguire l'autenticazione con Azure Pipelines

Usare un token di accesso personale (PAT) per connettere l'account GitHub ad Azure DevOps. È possibile generare un token di accesso personale dall'interno di Azure DevOps e quindi archiviarlo come segreto GitHub. All'interno del flusso di lavoro GitHub fare riferimento al segreto in modo che l'azione GitHub possa eseguire l'autenticazione con il progetto Azure DevOps.

Aprire il repository GitHub e passare a Impostazioni.
Selezionare Sicurezza > Segreti e variabili > Azioni.
Incollare il pat e assegnare il nome AZURE_DEVOPS_TOKEN.
Selezionare Aggiungi segreto.

Creare un flusso di lavoro GitHub che compila un artefatto

I flussi di lavoro di GitHub sono una serie di azioni, ad esempio le attività in Azure Pipelines. Questo flusso di lavoro:

Configura un ambiente dell'interfaccia della riga di comando di .NET Core usando l'azione setup-dotnet.
Ripristina le dipendenze, compila il progetto e le relative dipendenze in un set di file binari ed esegue tutti gli unit test associati al progetto.
Inserisce il codice in un pacchetto NuGet con la variabile di ambiente GitHub Run ID inclusa nel numero di versione.
Pubblica il pacchetto NuGet in Azure Artifacts.

Creare un nuovo file YAML

Nel repository GitHub creare un nuovo file YAML nella .github/workflows directory.

Copiare il contenuto seguente nel file YAML. Personalizzare i AZURE_ARTIFACTS_FEED_URLvalori , BUILD_CONFIGURATIONe DOTNET_VERSION .

Impostare AZURE_ARTIFACTS_FEED_URL sull'URL del registro per il feed di Azure Artifacts.
Impostare BUILD_CONFIGURATION.
Impostare DOTNET_VERSION sulla versione del progetto.

name: Push a NuGet package to Azure Artifacts

on:
  push:
    branches:
      - main

env:
  AZURE_ARTIFACTS_FEED_URL: https://pkgs.dev.azure.com/myorg/nuget-artifact/_packaging/Fabrikam_Feed/nuget/v3/index.json    
  BUILD_CONFIGURATION: 'Release'    # set this to the appropriate build configuration
  DOTNET_VERSION: '6.x' 

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Checkout the repo
      - uses: actions/checkout@v2

      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Run dotnet build and package
      - name: dotnet build and test
        run: |
          dotnet restore
          dotnet build --configuration '${{ env.BUILD_CONFIGURATION }}'
          dotnet test --configuration '${{ env.BUILD_CONFIGURATION }}'

  az-artifacts-build-and-deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      # Checkout the repo
      - uses: actions/checkout@v2

      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}
          source-url: ${{ env.AZURE_ARTIFACTS_FEED_URL }}
        env:
          NUGET_AUTH_TOKEN: ${{ secrets.AZURE_DEVOPS_TOKEN }} 

      # Run dotnet build and package
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration '${{ env.BUILD_CONFIGURATION }}'
          dotnet pack -c '${{ env.BUILD_CONFIGURATION }}' --version-suffix $GITHUB_RUN_ID

      # Publish the package to Azure Artifacts
      - name: 'dotnet publish'
        run: dotnet nuget push bin/Release/*.nupkg --api-key AzureDevOps --source ${{ env.AZURE_ARTIFACTS_FEED_URL }}

Passare al feed di Azure Artifacts per verificare che venga visualizzato il pacchetto di cui è stato eseguito il push.

Pulire le risorse

Se non si prevede di continuare a usare il flusso di lavoro di GitHub, disabilitare il flusso di lavoro.

Passaggi successivi

Eseguire la distribuzione in Azure usando GitHub Actions

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-01-14

Condividi tramite

Guida introduttiva: Usare GitHub Actions per eseguire il push in Azure Artifacts

Prerequisiti

Assegnare autorizzazioni all'identità gestita in Azure DevOps

Creare segreti di GitHub

Creare un flusso di lavoro GitHub che compila un artefatto

Creare un nuovo file YAML

Prerequisiti

Eseguire l'autenticazione con Azure Pipelines

Creare un flusso di lavoro GitHub che compila un artefatto

Creare un nuovo file YAML

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive