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.

• 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:

Prodotto	Requisiti
Azure DevOps	- Un progetto Azure DevOps. - La possibilità di eseguire pipeline su agenti ospitati da Microsoft. È possibile acquistare un incarico parallelo oppure richiedere un piano gratuito. - Conoscenza di base di YAML e Azure Pipelines. Per maggiori informazioni, vedere Creare la prima pipeline. Autorizzazioni - :      - Per creare una pipeline, è necessario trovarsi nel gruppo Collaboratori e il gruppo deve avere l'autorizzazione Crea pipeline di compilazione impostata su Consenti. I membri del gruppo Project Administrators possono gestire le pipeline.     - Per creare connessioni al servizio: è necessario disporre del ruolo di Administrator o Creator per le connessioni al servizio .
GitHub	- Un account GitHub. - Una connessione al servizio GitHub per autorizzare Azure Pipelines.
Azzurro	Una sottoscrizione di Azure.

Annotazioni

GitHub potrebbe richiedere l'autenticazione, l'autorizzazione o l'accesso a organizzazioni GitHub o a repository specifici. Seguire le istruzioni per completare i processi necessari. Per altre informazioni, vedere Accedere ai repository GitHub.

Pipeline di esempio

L'esempio seguente del file azure-pipelines.yml basato sul template PHP come App Web Linux su Azure ha due fasi: e Build. 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 viene eseguita se la fase Build ha esito positivo e distribuisce il pacchetto drop in App Service mediante il task 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.

Annotazioni

Se crei la pipeline dal modello App Web PHP come Linux su Azuretemplate, e la tua app PHP non usa Composer, rimuovi le righe seguenti dalla pipeline generata prima di salvarla ed eseguirla. La pipeline del modello fallisce così com'è se composer.json non sia presente nel repository.

    - 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.

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

Più versioni php vengono installate in agenti Ubuntu ospitati da Microsoft. 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, è possibile puntare il collegamento simbolico alla versione desiderata usando il update-alternatives comando . Nella pipeline YAML modificare il valore della phpVersion variabile con la versione desiderata e usare il frammento di codice seguente:

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)'

Installa le dipendenze

Per usare Composer per installare le dipendenze, includere il frammento di codice seguente nel file azure-pipelines.yml :

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

Se il file composer.json non si trova nella directory radice, è possibile usare l'argomento --working-dir per specificare quale directory 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 test con PHPUnit, aggiungere il frammento di codice seguente al file azure-pipelines.yml :

- script: ./phpunit
  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

Contenuti correlati

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