Condividi tramite

Recapito continuo con Azure Pipelines

Usare Azure Pipelines per distribuire automaticamente il progetto di codice in un'app per le funzioni in Azure. Azure Pipelines consente di creare, testare e distribuire integrazione continua (CI, continuous integration) e recapito continuo (CD, continuous delivery) tramite Azure DevOps.

Le pipeline YAML vengono definite usando un file YAML nel repository. Un passaggio è il blocco predefinito più piccolo di una pipeline e può essere uno script o un’attività (script prepacchetto). Informazioni su concetti chiave e componenti che costituiscono una pipeline.

Usare l'attività AzureFunctionApp per distribuire il codice. In questa tabella sono ora disponibili due versioni di AzureFunctionApp, che vengono confrontate:

Confronto/versione AzureFunctionApp@2 AzureFunctionApp@1
Supporta il piano di consumo flessibile ✔ ❌
Include il supporto avanzato per la convalida* ✔ ❌
Quando usare... Consigliato per le nuove distribuzioni di app Mantenuto per le distribuzioni legacy

* Il supporto della convalida avanzata rende meno probabile che le pipeline non riescano a causa di errori.

Scegliere la versione dell'attività nella parte superiore dell'articolo.

Note

Eseguire l'aggiornamento da AzureFunctionApp@1 a AzureFunctionApp@2 per l'accesso alle nuove funzionalità e al supporto a lungo termine.

Prerequisiti

Ricordarsi di caricare il progetto di codice locale nel repository GitHub o Azure Repos dopo la pubblicazione nell'app per le funzioni.

Creare l'app

  1. Accedere all'organizzazione di Azure DevOps e passare al progetto.
  2. Nel progetto passare alla pagina Pipeline. Quindi scegliere l'azione per creare una nuova pipeline.
  3. Eseguire i passaggi della procedura guidata selezionando prima di tutto GitHub come posizione del codice sorgente.
  4. Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.
  5. Quando viene visualizzato l'elenco dei repository, selezionare quello dell'app di esempio.
  6. Azure Pipelines analizzerà il repository e consiglierà un modello. Selezionare Salva ed esegui, quindi Commit directly to the main branch (Esegui il commit direttamente nel ramo principale) e infine di nuovo Salva ed esegui.
  7. Viene avviata una nuova esecuzione. Attendere che venga completata.

Pipeline di compilazione YAML di esempio

Per la compilazione di app, è possibile usare le pipeline specifiche del linguaggio seguenti.

È possibile usare l'esempio seguente per creare un file YAML per compilare un'app .NET:

pool:
  vmImage: 'windows-latest'
steps:
  - task: UseDotNet@2
    displayName: 'Install .NET 8.0 SDK'
    inputs:
      packageType: 'sdk'
      version: '8.0.x'
      installationPath: $(Agent.ToolsDirectory)/dotnet
  - script: |
      dotnet restore
      dotnet build --configuration Release
  - task: DotNetCoreCLI@2
    displayName: 'dotnet publish'
    inputs:
      command: publish
      arguments: '--configuration Release --output $(System.DefaultWorkingDirectory)/publish_output'
      projects: 'csharp/*.csproj'
      publishWebProjects: false
      modifyOutputPath: false
      zipAfterPublish: false
  - task: ArchiveFiles@2
    displayName: "Archive files"
    inputs:
      rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
      includeRootFolder: false
      archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
  - task: PublishBuildArtifacts@1
    inputs:
      PathtoPublish: '$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip'
      artifactName: 'drop'
  1. Accedere all'organizzazione di Azure DevOps e passare al progetto.
  2. Nel progetto passare alla pagina Pipeline. Selezionare quindi Nuova pipeline.
  3. Selezionare una di queste opzioni per Dove si trova il codice?:
    • GitHub: si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub. Quando questa connessione è la prima connessione a GitHub, la procedura guidata illustra anche il processo di connessione di DevOps agli account GitHub.
    • Azure Repos Git: è possibile scegliere immediatamente un repository nel progetto DevOps corrente.
  4. Quando viene visualizzato l'elenco dei repository, selezionare quello dell'app di esempio.
  5. Azure Pipelines analizza il repository e in Configurare la pipeline fornisce un elenco di modelli potenziali. Scegliere il modello app per le funzioni appropriato per la lingua. Se il modello corretto non viene visualizzato, selezionare Mostra altro.
  6. Selezionare Salva ed esegui, quindi Commit directly to the main branch (Esegui il commit direttamente nel ramo principale) e infine di nuovo Salva ed esegui.
  7. Viene avviata una nuova esecuzione. Attendere che venga completata.

Pipeline di compilazione YAML di esempio

Per la compilazione di app, è possibile usare le pipeline specifiche del linguaggio seguenti.

È possibile usare l'esempio seguente per creare un file YAML per compilare un'app .NET.

Se vengono visualizzati errori durante la compilazione dell'app, verificare che la versione di .NET usata corrisponda alla versione di Funzioni di Azure. Per altre informazioni, vedere Panoramica delle versioni del runtime per Funzioni di Azure.

pool:
  vmImage: 'windows-latest'
steps:
  - task: UseDotNet@2
    displayName: 'Install .NET 8.0 SDK'
    inputs:
      packageType: 'sdk'
      version: '8.0.x'
      installationPath: $(Agent.ToolsDirectory)/dotnet
  - script: |
      dotnet restore
      dotnet build --configuration Release
  - task: DotNetCoreCLI@2
    displayName: 'dotnet publish'
    inputs:
      command: publish
      arguments: '--configuration Release --output $(System.DefaultWorkingDirectory)/publish_output'
      projects: 'csharp/*.csproj'
      publishWebProjects: false
      modifyOutputPath: false
      zipAfterPublish: false
  - task: ArchiveFiles@2
    displayName: "Archive files"
    inputs:
      rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
      includeRootFolder: false
      archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
  - task: PublishBuildArtifacts@1
    inputs:
      PathtoPublish: '$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip'
      artifactName: 'drop'

Distribuire l'app Web

Si distribuirà con l'attività Distribuzione v2 app per le funzioni di Azure. Questa attività richiede una Connessione al servizio di Azure come input. Una connessione al servizio di Azure archivia le credenziali per connettersi da Azure Pipelines ad Azure. È consigliabile creare una connessione che usa la federazione dell'identità del carico di lavoro.

Per eseguire la distribuzione in Funzioni di Azure, aggiungere questo frammento di codice alla fine del azure-pipelines.yml file, a seconda che l'app venga eseguita in Linux o Windows:

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <Name of your Azure subscription>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip
    deploymentMethod: 'auto' # 'auto' | 'zipDeploy' | 'runFromPackage'. Required. Deployment method. Default: auto.
    #Uncomment the next lines to deploy to a deployment slot
    #Note that deployment slots is not supported for Linux Dynamic SKU
    #deployToSlotOrASE: true
    #resourceGroupName: '<RESOURCE_GROUP>'
    #slotName: '<SLOT_NAME>'

Il valore predefinito appType è Windows (functionApp). È possibile specificare Linux impostando appType su functionAppLinux. Un'app Flex Consumption viene eseguita in Linux ed è necessario impostare sia appType: functionAppLinux che isFlexConsumption: true.

Il frammento presuppone che i passaggi di compilazione nel file YAML producano l'archivio ZIP nella cartella $(System.ArtifactsDirectory) dell'agente.

Si distribuirà con l'attività Distribuzione app per le funzioni di Azure. Questa attività richiede una Connessione al servizio di Azure come input. Una connessione al servizio di Azure archivia le credenziali per connettersi da Azure Pipelines ad Azure.

Importante

La distribuzione in un'app Flex Consumption non è supportata utilizzando @v1 dell'attivitàAzureFunctionApp.

Per eseguire la distribuzione in Funzioni di Azure, aggiungere questo frammento di codice alla fine del azure-pipelines.yml file:

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'ubuntu-latest'

- task: DownloadBuildArtifacts@1 # Add this at the end of your file
  inputs:
    buildType: 'current'
    downloadType: 'single'
    artifactName: 'drop'
    itemPattern: '**/*.zip'
    downloadPath: '$(System.ArtifactsDirectory)'
- task: AzureFunctionApp@1
  inputs:
    azureSubscription: $(azureSubscription)
    appType: functionAppLinux # default is functionApp
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.zip

Questo frammento di codice imposta il appType su functionAppLinux, necessario per la distribuzione su un'applicazione che gira su Linux. Il valore predefinito appType è Windows (functionApp).

L'esempio presuppone che i passaggi di compilazione nel file YAML producano l'archivio ZIP nella cartella dell'agente $(System.ArtifactsDirectory) .

Distribuire un contenitore

Suggerimento

È consigliabile usare il supporto di Azure Functions in Azure Container Apps per ospitare l'app per le funzioni in un contenitore personalizzato di Linux. Per altre informazioni, vedere Panoramica di Funzioni di Azure in App Azure Container.

Quando si distribuisce un'app per le funzioni in contenitori, l'attività di distribuzione usata dipende dall'ambiente di hosting specifico.

È possibile usare l'attività Distribuisci app di Azure Container (AzureContainerApps) per distribuire un'immagine di un'app per le funzioni in un'istanza di Azure Container App ottimizzata per Azure Functions.

Questo codice distribuisce l'immagine di base per un'app per le funzioni del modello di processo isolato .NET 8:

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: AzureContainerApps@1
  inputs:
    azureSubscription: <Name of your Azure subscription>
    imageToDeploy: 'mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0'
    containerAppName: <Name of your container app>
    resourceGroup: <Name of the resource group>

Idealmente, è consigliabile creare un contenitore personalizzato nella pipeline anziché usare un'immagine di base, come illustrato in questo esempio. Per altre informazioni, vedere Distribuire nelleApp contenitore di Azure da Azure Pipelines.

Eseguire la distribuzione in uno slot

Importante

Il piano Flex Consumption attualmente non supporta gli slot. Le app Linux non supportano gli slot quando vengono eseguite in un piano a consumo e il supporto per queste app sarà ritirato in futuro.

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <Name of your Azure subscription>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip
    deploymentMethod: 'auto' # 'auto' | 'zipDeploy' | 'runFromPackage'. Required. Deployment method. Default: auto.
    deployToSlotOrASE: true
    resourceGroupName: '<RESOURCE_GROUP>'
    slotName: '<SLOT_NAME>'

È possibile configurare l'app per le funzioni in modo che disponga di più slot. Gli slot consentono di distribuire in modo sicuro l'app e testarla prima di renderla disponibile ai clienti.

Il frammento di codice YAML seguente illustra come eseguire la distribuzione in uno slot di staging e quindi passare a uno slot di produzione:

- task: AzureFunctionApp@1
  inputs:
    azureSubscription: <Azure service connection>
    appType: functionAppLinux
    appName: <Name of the function app>
    package: $(System.ArtifactsDirectory)/**/*.zip
    deployToSlotOrASE: true
    resourceGroupName: <Name of the resource group>
    slotName: staging

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: <Azure service connection>
    WebAppName: <name of the function app>
    ResourceGroupName: <name of resource group>
    SourceSlot: staging
    SwapWithProduction: true

Quando si usano gli slot di distribuzione, è anche possibile aggiungere l'attività seguente per eseguire uno scambio di slot come parte della distribuzione.

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: <AZURE_SERVICE_CONNECTION>
    WebAppName: <APP_NAME>
    ResourceGroupName: <RESOURCE_GROUP>
    SourceSlot: <SLOT_NAME>
    SwapWithProduction: true

Creare una pipeline con l'interfaccia della riga di comando di Azure

Per creare una pipeline di compilazione in Azure, usare il az functionapp devops-pipeline createcomando. La pipeline di compilazione viene creata per compilare e rilasciare tutte le modifiche al codice apportate nel repository. Il comando genera un nuovo file YAML che definisce la pipeline di compilazione e versione e quindi ne esegue il commit nel repository. I prerequisiti per questo comando dipendono dalla posizione del codice.

  • Se il codice si trova in GitHub:

    • È necessario disporre di autorizzazioni di scrittura per la sottoscrizione.

    • È necessario essere l'amministratore del progetto in Azure DevOps.

    • È necessario disporre delle autorizzazioni per creare un token di accesso personale (PAT) di GitHub con autorizzazioni sufficienti. Per altre informazioni, vedere Requisiti di autorizzazione PAT di GitHub.

    • È necessario disporre delle autorizzazioni per eseguire il commit nel ramo principale nel repository GitHub in modo da poter eseguire il commit del file YAML generato automaticamente.

  • Se il codice si trova in Azure Repos:

    • È necessario disporre di autorizzazioni di scrittura per la sottoscrizione.

    • È necessario essere l'amministratore del progetto in Azure DevOps.

Passaggi successivi

  • Last updated on