Compilare, testare e distribuire app PHP

Servizi di Azure DevOps

Questo articolo illustra come creare una pipeline in Azure Pipelines che compila un'app Web PHP e la distribuisce nel servizio app di Azure. Il servizio app è un servizio basato su HTTP per l'hosting di applicazioni Web, API REST e back-end per dispositivi mobili. La pipeline utilizza l'integrazione continua dalla risorsa GitHub e la consegna continua ad App Service per buildare, testare e distribuire automaticamente le app PHP.

Azure Pipelines compila i progetti PHP senza dover configurare alcuna infrastruttura. PHP è preinstallato in agenti ospitati da Microsoft, insieme a molte librerie comuni per le versioni PHP. È possibile usare agenti Linux, macOS o Windows per eseguire le compilazioni. Per altre informazioni sulle versioni php preinstallate, vedere Software.

Prerequisiti

• Il proprio fork del progetto GitHub PHP di esempio all'indirizzo https://github.com/Azure-Samples/php-docs-hello-world.

  Suggerimento

  Il progetto di esempio usa le impostazioni predefinite del fuso orario php, che per impostazione predefinita sono UTC negli agenti ospitati da Microsoft. Se l'app richiede un fuso orario specifico, vedere Impostare il fuso orario PHP.

• Un'app Web PHP creata per il progetto nel servizio app di Azure. Per creare rapidamente un'app Web PHP, vedere Creare un'app Web PHP nel servizio app di Azure. È anche possibile usare il proprio progetto GitHub PHP e l'app Web.

Sono necessari anche i prerequisiti seguenti:

Pipeline di esempio

Il seguente file di esempio azure-pipelines.yml, basato sul modelloPHP come app web Linux su Azure, ha due fasi: Build e Deploy. La Build fase installa PHP 8.2 e quindi esegue attività per archiviare i file di progetto e pubblicare un artefatto di compilazione ZIP in un pacchetto denominato drop.

La fase Deploy è eseguita se la fase Build riesce. Distribuisce il drop pacchetto in App Service usando l'attività App Web di Azure. Quando si usa PHP come app Web Linux in Azure per creare la pipeline, la pipeline generata imposta e usa variabili e altri valori in base alle impostazioni di configurazione.

    - script: composer install --no-interaction --prefer-dist
     workingDirectory: $(rootFolder)
     displayName: 'Composer install'

trigger:
- main

variables:
  # Azure Resource Manager service connection
  azureSubscription: 'service-connection-based-on-subscription-id'
  # Web app name
  webAppName: 'my-php-web-app'
  # Agent VM image name
  vmImageName: 'ubuntu-22.04'
  # Environment name
  environmentName: 'my-php-web-app-environment'
  # Root folder where your composer.json file is available.
  rootFolder: $(System.DefaultWorkingDirectory)

stages:
- stage: Build
  displayName: Build stage
  variables:
    phpVersion: '8.2'
  jobs:
  - job: BuildJob
    pool:
      vmImage: $(vmImageName)
    steps:
    - script: |
        sudo update-alternatives --set php /usr/bin/php$(phpVersion)
        sudo update-alternatives --set phar /usr/bin/phar$(phpVersion)
        sudo update-alternatives --set phpdbg /usr/bin/phpdbg$(phpVersion)
        sudo update-alternatives --set php-cgi /usr/bin/php-cgi$(phpVersion)
        sudo update-alternatives --set phar.phar /usr/bin/phar.phar$(phpVersion)
        php -version
      workingDirectory: $(rootFolder)
      displayName: 'Use PHP version $(phpVersion)'

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(rootFolder)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      displayName: 'Upload package'
      artifact: drop

- stage: Deploy
  displayName: 'Deploy Web App'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: DeploymentJob
    pool:
      vmImage: $(vmImageName)
    environment: $(environmentName)
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Deploy Azure Web App'
            inputs:
              azureSubscription: $(azureSubscription)
              appName: $(webAppName)
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

Creare la pipeline YAML

Per creare ed eseguire la pipeline di esempio, seguire questa procedura:

1. Nel progetto Azure DevOps selezionare Pipeline dal menu di spostamento a sinistra e quindi selezionare Nuova pipeline o Crea pipeline se la pipeline è la prima nel progetto.

2. Nella pagina Where is your code, selezionare GitHub.

3. Nella pagina Selezionare un repository selezionare il repository php-docs-hello-world creato tramite fork.

4. Azure Pipelines riconosce il codice come app PHP e suggerisce diversi modelli di pipeline nella pagina Configurare la pipeline . Per questo esempio, selezionare PHP come App Web Linux in Azure.

5. Nella schermata successiva selezionare la sottoscrizione di Azure e selezionare Continua. Questa azione crea una connessione di servizio alle risorse di Azure.

6. Nella schermata successiva selezionare l'app Web di Azure e selezionare Convalida e configura. Azure Pipelines crea un file azure-pipelines.yml e lo visualizza nell'editor della pipeline YAML.

7. Nella schermata Review your pipeline YAML (Esaminare il codice YAML della pipeline ) esaminare il codice per la pipeline. Quando si è pronti, selezionare Salva ed esegui.

   

8. Nella schermata successiva selezionare Salva ed eseguire di nuovo per eseguire il commit del nuovo file azure-pipelines.yml nel repository e avviare una compilazione CI/CD.

   Annotazioni

   La prima volta che viene eseguita la pipeline, viene richiesta l'autorizzazione per accedere all'ambiente creato. Selezionare Consenti per concedere alla pipeline l'autorizzazione per accedere all'ambiente.

9. Per osservare la tua pipeline in azione, selezionare il job nella pagina Riepilogo dell'esecuzione. Quando l'esecuzione è completata, selezionare il collegamento URL dell'applicazione del servizio App nel passaggio Distribuisci app Web di Azure per visualizzare l'app Web distribuita.

10. Verificare che la distribuzione sia riuscita passando all'URL. Verrà visualizzato l'output Hello World! dell'app di esempio.

Personalizzare la pipeline

È possibile modificare la pipeline selezionando l'icona Altre azioni in alto a destra nella pagina di Riepilogo dell'esecuzione e quindi selezionando Modifica pipeline, oppure selezionando Modifica in alto a destra sulla pagina della pipeline. Ogni modifica di cui si esegue il commit nel repository avvia una nuova esecuzione della pipeline CI/CD.

È possibile personalizzare la pipeline in diversi modi:

Usare una versione PHP specifica

Gli agenti Ubuntu ospitati da Microsoft hanno più versioni PHP installate. Un collegamento simbolico in /usr/bin/php punta alla versione PHP corrente, quindi quando si esegue php, viene eseguita la versione set.

Per usare una versione PHP diversa da quella predefinita, puntare il collegamento simbolico alla versione desiderata usando il update-alternatives comando . Nella pipeline YAML modificare il valore della phpVersion variabile impostando la versione desiderata. Aggiungere il seguente frammento di codice alle sezioni variables e steps della fase di compilazione.

variables:
  phpVersion: 8.3

steps:
- script: |
    sudo update-alternatives --set php /usr/bin/php$(phpVersion)
    sudo update-alternatives --set phar /usr/bin/phar$(phpVersion)
    sudo update-alternatives --set phpdbg /usr/bin/phpdbg$(phpVersion)
    sudo update-alternatives --set php-cgi /usr/bin/php-cgi$(phpVersion)
    sudo update-alternatives --set phar.phar /usr/bin/phar.phar$(phpVersion)
    php -version
  displayName: 'Use PHP version $(phpVersion)'

Impostare il fuso orario PHP

Gli agenti ospitati da Microsoft utilizzano UTC per impostazione predefinita, quindi le funzioni PHP, come date() e strtotime(), restituiscono valori UTC. Per usare un fuso orario diverso negli script della pipeline, impostare la TZ variabile di ambiente o chiamare date_default_timezone_set() nel codice PHP.

Nell'esempio seguente il fuso orario viene impostato sull'ora orientale per un passaggio di script. Aggiungere questo frammento di codice alla steps sezione del processo di compilazione:

- script: |
    export TZ='America/New_York'
    php -r "date_default_timezone_set('America/New_York'); echo date('Y-m-d H:i:s T');"
  displayName: 'Run PHP with Eastern time zone'

Per un elenco degli identificatori di fuso orario supportati, vedere l'elenco PHP dei fusi orari supportati.

Installa le dipendenze

Per usare Composer per installare le dipendenze, aggiungere il frammento di codice seguente alla steps sezione del processo di compilazione:

- script: composer install --no-interaction --prefer-dist
  displayName: 'composer install'

Se il file composer.json non si trova nella directory radice, usare l'argomento --working-dir per specificare la directory da usare. Ad esempio, se composer.json si trova nella sottocartella /pkgs, usare composer install --no-interaction --working-dir=pkgs. È anche possibile specificare un percorso assoluto usando la variabile di sistema predefinita: --working-dir='$(System.DefaultWorkingDirectory)/pkgs'.

Test con PHPUnit

Per eseguire i test con PHPUnit, installarlo prima come dipendenza di sviluppo con Composer e quindi eseguirlo. Aggiungere il frammento di codice seguente alla sezione steps del processo di build.

- script: composer require --dev phpunit/phpunit
  displayName: 'Install PHPUnit'

- script: vendor/bin/phpunit --log-junit $(Build.StagingDirectory)/test-results.xml
  displayName: 'Run tests with PHPUnit'

Mantenere gli artefatti PHP con il record di compilazione

Per salvare gli artefatti generati dalla build con il record della build, includere l'attività Archivia file nella pipeline e, facoltativamente, personalizzare il valore di rootFolderOrFile per modificare i contenuti dell'archivio.

- task: ArchiveFiles@2
  inputs:
    rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
    includeRootFolder: false

Troubleshoot

Errori di connessione del servizio

Se la pipeline non riesce con un errore di autorizzazione durante la distribuzione, verificare che la connessione al servizio Azure Resource Manager sia configurata correttamente e disponga delle autorizzazioni necessarie per la distribuzione nel Servizio App.

Errori di installazione di Composer

In caso composer install di esito negativo, verificare che il file composer.json sia presente nella directory di lavoro. Se il file si trova in una sottodirectory, usare l'argomento --working-dir . Se composer.json non esiste nel repository, rimuovere il passaggio Composer dalla pipeline.

Versione PHP non disponibile

Se update-alternatives fallisce con un errore simile a no alternatives for php8.x, la versione PHP richiesta non è installata nell'immagine dell'agente. Controllare l'elenco di software dell'agente ospitato da Microsoft per le versioni PHP disponibili.

Autorizzazione di distribuzione negata

Se la fase di distribuzione ha esito negativo con un errore di autorizzazione, verificare che:

• La connessione al servizio ha il ruolo Collaboratore nella risorsa App Service.
• La pipeline ha l'autorizzazione per accedere all'ambiente. Nella prima esecuzione selezionare Consenti quando richiesto.

Contenuti correlati

• Distribuire su App Service utilizzando Azure Pipelines
• Attività di distribuzione
• Modelli YAML nelle pipeline