Compilare e testare app PHP

Servizi di Azure DevOps

Usare l'integrazione continua e il recapito continuo (CI/CD) di Azure Pipelines per compilare, distribuire e testare i progetti PHP.

Informazioni su come creare una pipeline PHP, distribuire una pipeline con un progetto di esempio nel servizio app di Azure e come configurare l'ambiente.

Per altre informazioni sul servizio app di Azure, vedere Creare un'app Web PHP nel servizio app di Azure.

Prerequisiti

Se si intende eseguire la distribuzione nel servizio app di Azure, è necessario creare un'app Web.

Ottenere il codice

Se si ha già un'app in GitHub che si vuole distribuire, è possibile creare una pipeline per tale codice. Tuttavia, se si è un nuovo utente, è possibile iniziare meglio usando il codice di esempio. In tal caso, creare una copia tramite fork del seguente repository su GitHub.

https://github.com/Azure-Samples/basic-php-composer

Creare un flusso di lavoro

1. Accedere all'organizzazione di Azure DevOps e passare al progetto.

2. Passare alle pipeline e quindi selezionare Nuova pipeline.

3. Selezionare il percorso di origine (GitHub, Azure Repos Git, Bitbucket Cloud o altri repository Git).

4. Selezionare il repository in cui si trova il codice.

5. Selezionare PHP nella scheda Configura .

6. Verificare che la versione di PHP sia 8.3.

7. Esamina la nuova pipeline. Quando si è pronti, selezionare Salva ed esegui.

   

8. Viene richiesto di eseguire il commit di un nuovo file azure-pipelines.yml nel repository. Selezionare Salva ed esegui di nuovo.

   Se vuoi guardare la tua pipeline in azione, seleziona il processo di build.

   È ora disponibile una pipeline YAML funzionante (azure-pipelines.yml) nel repository pronto per la personalizzazione.

Quando si desidera apportare modifiche alla pipeline, selezionare la pipeline nella pagina Pipeline e quindi Modificare il file azure-pipelines.yml .

Leggi di più per scoprire alcuni dei modi più comuni per personalizzare la tua pipeline.

Eseguire la distribuzione in App Service

Usare una pipeline per creare un'app Web PHP e distribuirla nel servizio app di Azure. Il Servizio app di Azure è un servizio per l'hosting di applicazioni Web, API REST e back-end mobili, basato su HTTP.

È possibile usare le attività per archiviare i file, pubblicare un artefatto di compilazione e quindi usare l'attività App Web di Azure per la distribuzione nel servizio app di Azure.

Questa pipeline ha due fasi: Compilazione e distribuzione. Nella fase di compilazione, PHP 8.3 viene installato con composer. I file dell'app vengono archiviati e caricati in un pacchetto denominato drop. Durante la fase di distribuzione, il drop pacchetto viene distribuito nel servizio app di Azure come app Web.

trigger:
- main

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureSubscription: 'subscription-id'
  # Web app name
  webAppName: 'web-app-name'
  # Agent VM image name
  vmImageName: 'ubuntu-22.04'
  # Environment name
  environmentName: 'environment-name'
  # Root folder under which your composer.json file is available.
  rootFolder: $(System.DefaultWorkingDirectory)

stages:
- stage: Build
  displayName: Build stage
  variables:
    phpVersion: '8.3'
  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)'

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

    - 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

Configurare l'ambiente di compilazione

Usare Azure Pipelines per compilare i progetti PHP senza configurare l'infrastruttura.

Usare una versione PHP specifica

PHP è preinstallato in agenti ospitati da Microsoft, insieme a molte librerie comuni per ogni versione di PHP. È possibile usare agenti Linux, macOS o Windows per eseguire le compilazioni. Per altre informazioni e le versioni esatte di PHP preinstallate, vedere Agenti ospitati da Microsoft.

Nell'agente Ubuntu ospitato da Microsoft vengono installate più versioni di PHP. Il collegamento simbolico su /usr/bin/php punta alla versione PHP attualmente impostata, in modo che, quando si esegue php, venga eseguita la versione impostata.

Per usare una versione PHP diversa dall'impostazione predefinita, il collegamento simbolico può essere puntato verso tale versione usando lo strumento update-alternatives. Impostare la versione PHP desiderata aggiungendo il frammento di codice seguente al azure-pipelines.yml file e modificare il valore della variabile phpVersion .

pool:
  vmImage: 'ubuntu-22.04'

variables:
  phpVersion: 8.2

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, aggiungere il frammento di codice seguente al azure-pipelines.yml file.

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

Test con phpunit

Per eseguire test con phpunit, aggiungere il frammento di codice seguente al azure-pipelines.yml file.

- script: ./phpunit
  displayName: 'Run tests with phpunit'

Mantenere l'app PHP con il record di compilazione

Per salvare gli artefatti di questa compilazione con il record di compilazione, aggiungere il frammento di codice seguente al azure-pipelines.yml file. Facoltativamente, personalizzare il valore di rootFolderOrFile per modificare gli elementi inclusi nell'archivio.

- task: ArchiveFiles@2
  inputs:
    rootFolderOrFile: '$(system.defaultWorkingDirectory)'
    includeRootFolder: false
- task: PublishBuildArtifacts@1

Uso di una posizione personalizzata del compositore

Se il composer.json si trova in una sottocartella anziché nella directory radice, è possibile usare l'argomento --working-dir per indicare a composer quale directory usare. Ad esempio, se il file composer.json si trova all'interno della sottocartella pkgs

composer install --no-interaction --working-dir=pkgs

È anche possibile specificare il percorso assoluto usando le variabili di sistema predefinite:

composer install --no-interaction --working-dir='$(system.defaultWorkingDirectory)/pkgs'