Compilación y prueba de aplicaciones PHP

Artículo
05/20/2024

Azure DevOps Services

Use la integración continua y entrega continua (CI/CD) de Azure Pipelines para compilar, implementar y probar los proyectos PHP.

Aprenda a crear una canalización PHP, a implementar una canalización con un proyecto de ejemplo en Azure App Service y a configurar el entorno.

Para más información sobre Azure App Service, consulte Creación de una aplicación web PHP en Azure App Service.

Requisitos previos

Asegúrese de que dispone de lo siguiente:

Una cuenta de GitHub en la que pueda crear un repositorio. cree una de forma gratuita.
Una organización de Azure DevOps. cree una de forma gratuita. Si el equipo ya tiene una, asegúrese de que usted es el administrador del proyecto de Azure DevOps que desea usar.
Tener capacidad para ejecutar canalizaciones en agentes hospedados por Microsoft. Para usar agentes hospedados por Microsoft, la organización de Azure DevOps debe tener acceso a trabajos paralelos hospedados por Microsoft. Puede comprar un trabajo paralelo o solicitar una concesión gratuita.

Una cuenta de Azure. Si no tiene ninguna, puede crearla gratis.

Sugerencia

Si no está familiarizado con este proceso, la manera más fácil de empezar es usar la misma dirección de correo electrónico que el propietario de la organización de Azure Pipelines y la suscripción de Azure.

Si va a implementar en Azure App Service, debe tener una aplicación web creada.

Obtención del código

Si ya tiene una aplicación en GitHub que quiere implementar, puede intentar crear una canalización para ese código. Pero si es un usuario nuevo, es posible que sea mejor comenzar con nuestro código de ejemplo. En ese caso, bifurque el repositorio siguiente en GitHub:

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

Crear una canalización

Inicie sesión en su organización de Azure DevOps y vaya a su proyecto.
Vaya a las canalizaciones y seleccione Nueva canalización.
Seleccione la ubicación de origen (GitHub, Git de Azure Repos, Bitbucket Cloud u otros repositorios de Git).
Seleccione el repositorio donde se encuentre el código.
Seleccione PHP en la pestaña Configurar.
Asegúrese de que la versión de PHP es 8.3.
Examine la canalización nueva. Cuando esté listo, seleccione Guardar y ejecutar.
Se le pedirá que confirme un archivo azure-pipelines.yml nuevo en el repositorio. Selecciona Guardar y ejecutar nuevamente.

Si quiere ver la canalización en acción, seleccione el trabajo de compilación.

Ahora ya tiene una canalización YAML en funcionamiento (azure-pipelines.yml) en el repositorio que está lista para que la personalice.

Cuando quiera realizar cambios en la canalización, selecciónela en la canalización en la página Canalizaciones y, luego, haga clic en Editar para modificar el archivo azure-pipelines.yml.

Obtenga más información sobre algunas de las formas más comunes de personalizar la canalización.

Implementación en App Service

Use una canalización para compilar una aplicación web PHP e implementarla en Azure App Service. Azure App Service es un servicio basado en HTTP para hospedar aplicaciones web, API de REST y back-ends para dispositivos móviles.

Puede usar tareas para archivar los archivos, publicar un artefacto de compilación y, luego, usar la tarea de aplicación web de Azure para implementar en Azure App Service.

Esta canalización tiene dos fases: compilación e implementación. En la etapa de compilación, PHP 8.3 se instala con Composer. Los archivos de la aplicación se archivan y se cargan en un paquete denominado drop. Durante la fase de implementación, el paquete drop se implementa en Azure App Service como una aplicación 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

Configuración del entorno de compilación

Use Azure Pipelines para compilar los proyectos PHP sin configurar la infraestructura.

Uso de una versión de PHP específica

PHP está preinstalado en agentes hospedados por Microsoft, junto con muchas bibliotecas comunes por cada versión PHP. Puede usar agentes de Linux, macOS o Windows para ejecutar las compilaciones. Para más información y conocer las versiones exactas de PHP que están preinstaladas, consulte Agentes hospedados por Microsoft.

Son varias las versiones de PHP que se instalan en el agente de Ubuntu hospedado por Microsoft. Un vínculo simbólico en /usr/bin/php apunta a la versión de PHP establecida actualmente, de modo que, al ejecutar php, se ejecuta la versión establecida.

Para usar una versión PHP distinta de la predeterminada, el vínculo simbólico se puede apuntar a esa versión mediante la herramienta update-alternatives. Establezca la versión PHP que desea; para ello, agregue el fragmento de código siguiente al archivo azure-pipelines.yml y cambie el valor de la variable 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)'

Instalar dependencias

Para usar Composer para instalar dependencias, agregue este fragmento de código al archivo azure-pipelines.yml.

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

Prueba con phpunit

Para ejecutar pruebas con phpunit, agregue este fragmento de código al archivo azure-pipelines.yml.

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

Conservación de la aplicación PHP con el registro de compilación

Para guardar los artefactos de esta compilación con el registro de compilación, agregue este fragmento de código al archivo azure-pipelines.yml. También puede personalizar el valor de rootFolderOrFile para modificar lo que se incluye en el archivo.

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

Uso de una ubicación de Composer personalizada

Si composer.json está en una subcarpeta en lugar del directorio raíz, puede usar el argumento --working-dir para indicar a Composer qué directorio se va a usar. Por ejemplo, si composer.json está dentro de la subcarpeta pkgs

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

También puede especificar la ruta de acceso absoluta mediante las variables integradas del sistema:

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

Compartir vía