Compilare e testare app PHP

Articolo
05/21/2024

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 per app Azure Servizio e come configurare l'ambiente.

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

Prerequisiti

Assicurarsi di avere quanto segue:

Un account GitHub in cui è possibile creare un repository. Crearne una gratuitamente.
Un'organizzazione di Azure DevOps. Crearne una gratuitamente. Se il team ne ha già uno, assicurarsi di essere un amministratore del progetto Azure DevOps che si vuole usare.
Possibilità di eseguire pipeline su agenti ospitati da Microsoft. Per usare gli agenti ospitati da Microsoft, l'organizzazione Azure DevOps deve avere accesso ai processi paralleli ospitati da Microsoft. È possibile acquistare un processo parallelo oppure richiedere una concessione gratuita.

Un account Azure. Se non hai un account, puoi crearlo gratuitamente.

Suggerimento

Se non si ha familiarità, il modo più semplice per iniziare consiste nell'usare lo stesso indirizzo di posta elettronica del proprietario dell'organizzazione di Azure Pipelines e della sottoscrizione di Azure.

Se si intende eseguire la distribuzione nel servizio app 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 repository seguente in GitHub:

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

Creare una pipeline

Accedere all'organizzazione di Azure DevOps e passare al progetto.
Passare alle pipeline e quindi selezionare Nuova pipeline.
Selezionare il percorso di origine (GitHub, Azure Repos Git, Bitbucket Cloud o altri repository Git).
Selezionare il repository in cui si trova il codice.
Selezionare PHP nella scheda Configura .
Verificare che la versione di PHP sia 8.3.
Esaminare la nuova pipeline. Quando si è pronti, selezionare Salva ed esegui.
Viene richiesto di eseguire il commit di un nuovo file azure-pipelines.yml nel repository. Fare di nuovo clic su Save and run (Salva ed esegui).

Se si vuole controllare la pipeline in azione, selezionare il processo di compilazione.

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

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

Altre informazioni su alcuni dei modi più comuni per personalizzare la pipeline.

Distribuire nel servizio app

Usare una pipeline per compilare un'app Web PHP e distribuirla nel servizio app Azure. Servizio app di Azure è un servizio per l'hosting di applicazioni Web, API REST e back-end per dispositivi 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 eseguire la distribuzione nel servizio app 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 in app Azure Servizio 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-20.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. Collegamento simbolico in corrispondenza /usr/bin/php della versione PHP attualmente impostata, in modo che quando si esegue php, viene eseguita la versione set.

Per usare una versione PHP diversa dall'impostazione predefinita, il collegamento simbolico può essere indicato a tale versione usando lo update-alternatives strumento . 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-20.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)'

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

Condividi tramite