Condividi tramite

Recapito continuo con Azure Pipelines

  • Articolo

Usare Azure Pipelines per eseguire automaticamente la distribuzione in Funzioni di 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.

Si userà l'attività AzureFunctionApp per eseguire la distribuzione in Funzioni di Azure. Sono ora disponibili due versioni dell'attività AzureFunctionApp (AzureFunctionApp@1, AzureFunctionApp@2). AzureFunctionApp@2 include il supporto della convalida avanzata che rende meno probabile che le pipeline non riescano a causa di errori.

Scegliere la versione dell'attività nella parte superiore dell'articolo. Le pipeline YAML non sono disponibili per Azure DevOps 2019 e versioni precedenti.

Nota

Il AzureFunctionApp@2 è altamente consigliato. La distribuzione in un'app nel piano a consumo Flex è supportata solo nella versione 2.

Prerequisiti

Compilare l'app

  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 il completamento dell'esecuzione.

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:
- script: |
    dotnet restore
    dotnet build --configuration Release
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    arguments: '--configuration Release --output publish_output'
    projects: '*.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

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.

Per eseguire la distribuzione in Funzioni di Azure, aggiungere il frammento di codice seguente alla fine del file azure-pipelines.yml. Il appType predefinito è Windows. È possibile specificare Linux impostando appType su functionAppLinux. La distribuzione in un'app Flex Consumption non è supportata con @v1 l'attività AzureFunctionApp.

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: AzureFunctionApp@1 # Add this at the end of your file
  inputs:
    azureSubscription: <Azure service connection>
    appType: functionAppLinux # default is functionApp
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.zip
    #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 Name>'
    #slotName: '<Slot name>'

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

Distribuire un contenitore

È possibile distribuire automaticamente il codice come app per le funzioni in contenitori dopo ogni compilazione riuscita. Per altre informazioni sui contenitori, vedere Uso di contenitori e Funzioni di Azure.

Il modo più semplice per eseguire la distribuzione in un contenitore consiste nell'usare l'attività App per le funzioni di Azure in Distribuzione contenitore.

Per eseguire la distribuzione, aggiungere il frammento di codice seguente alla fine del file YAML:

trigger:
- main

variables:
  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: <Docker registry service connection>
  imageRepository: <Name of your image repository>
  containerRegistry: <Name of the Azure container registry>
  dockerfilePath: '$(Build.SourcesDirectory)/Dockerfile'
  tag: '$(Build.BuildId)'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

- task: AzureFunctionAppContainer@1 # Add this at the end of your file
  inputs:
    azureSubscription: '<Azure service connection>'
    appName: '<Name of the function app>'
    imageName: $(containerRegistry)/$(imageRepository):$(tag)

Il frammento esegue il push dell'immagine Docker nel Registro Azure Container. L'attività App per le funzioni di Azure in Distribuzione contenitore esegue il pull dell'immagine Docker appropriata corrispondente a BuildId dal repository specificato e quindi distribuisce l'immagine.

Per un esempio completo di pipeline end-to-end, inclusa la compilazione del contenitore e la pubblicazione nel registro contenitori, vedere questo esempio di distribuzione del contenitore di Azure Pipelines.

Eseguire la distribuzione in uno slot

È 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

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

Per creare una pipeline di compilazione in Azure, usare il comando az functionapp devops-pipeline create. 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.

Compilare 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 il completamento dell'esecuzione.

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:
- script: |
    dotnet restore
    dotnet build --configuration Release
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    arguments: '--configuration Release --output publish_output'
    projects: '*.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

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.

La versione v2 dell'attività include il supporto per gli stack di applicazioni più recenti per .NET, Python e Node. L'attività include controlli di pre-distribuzione della rete. Quando si verificano problemi di pre-distribuzione, la distribuzione si arresta.

Per eseguire la distribuzione in Funzioni di Azure, aggiungere il frammento di codice seguente alla fine del file azure-pipelines.yml. Il appType predefinito è Windows. È possibile specificare Linux impostando appType su functionAppLinux. Per la distribuzione in un'app Flex Consumption è necessario impostare sia appType: functionAppLinux che isFlexConsumption: true.

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <SUBSCRIPTION_NAME>
  appName: <APP_NAME>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <AZURE_SERVICE_CONNECTION>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.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>'

Passaggi successivi