Compilación, prueba e implementación de aplicaciones PHP

Azure DevOps Services

En este artículo se muestra cómo crear una canalización en Azure Pipelines que compila una aplicación web PHP e la implementa en Azure App Service. App Service es un servicio basado en HTTP para hospedar aplicaciones web, API REST y back-ends móviles. La canalización usa la integración continua desde el origen de GitHub y la entrega continua a App Service para compilar, probar e implementar aplicaciones PHP automáticamente.

Azure Pipelines compila los proyectos php sin tener que configurar ninguna infraestructura. PHP está preinstalado en agentes hospedados por Microsoft, junto con muchas bibliotecas comunes para versiones php. Puede usar agentes de Linux, macOS o Windows para ejecutar las compilaciones. Para obtener más información sobre qué versiones de PHP están preinstaladas, consulte Software.

Prerrequisitos

• Su propia bifurcación del proyecto php de GitHub de ejemplo en https://github.com/Azure-Samples/php-docs-hello-world.

• Una aplicación web PHP creada para el proyecto en Azure App Service. Para crear rápidamente una aplicación web PHP, consulte Creación de una aplicación web PHP en Azure App Service. También puede usar su propio proyecto y aplicación web de GitHub de PHP.

También necesita los siguientes requisitos previos:

Canalización de ejemplo

El siguiente ejemplo de archivo azure-pipelines.yml, basado en la plantilla de canalización PHP como Aplicación web en Linux en Azure, tiene dos fases, y . La Build fase instala PHP 8.2 y, a continuación, ejecuta tareas para archivar los archivos del proyecto y publicar un artefacto de compilación ZIP en un paquete denominado drop.

La Deploy etapa se ejecuta si la Build etapa tiene éxito e implementa el drop paquete en App Service mediante la tarea Azure Web App. Cuando usas la plantilla PHP como aplicación web Linux en Azure para crear tu tubería, la tubería generada establece y utiliza variables y otros valores según tus configuraciones.

    - 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

Creación de la canalización de YAML

Para crear y ejecutar la canalización de ejemplo, siga estos pasos:

1. En el proyecto de Azure DevOps, seleccione Canalizaciones en el menú de navegación izquierdo y, a continuación, seleccione Nueva canalización o Crear canalización si esta canalización es la primera del proyecto.

2. En la página Where is your code (Dónde está el código ), seleccione GitHub.

3. En la página Seleccionar un repositorio, seleccione el repositorio bifurcado php-docs-hello-world.

4. Azure Pipelines reconoce el código como una aplicación PHP y sugiere varias plantillas de canalización en la página Configurar la canalización . En este ejemplo, seleccione PHP como Aplicación web Linux en Azure.

5. En la pantalla siguiente, seleccione la suscripción de Azure y seleccione Continuar. Esta acción crea una conexión de servicio a los recursos de Azure.

6. En la pantalla siguiente, seleccione la aplicación web de Azure y seleccione Validar y configurar. Azure Pipelines crea un archivo azure-pipelines.yml y lo muestra en el editor de canalizaciones DE YAML.

7. En la pantalla Revisar tu canalización YAML, revisa el código de tu canalización. Cuando esté listo, seleccione Guardar y ejecutar.

   

8. En la siguiente pantalla, seleccione Guardar y ejecute de nuevo para confirmar el nuevo archivo azure-pipelines.yml en el repositorio e iniciar una compilación de CI/CD.

   Nota:

   La primera vez que se ejecuta la canalización, solicita permiso para acceder al entorno que crea. Seleccione Permitir para conceder permiso a la canalización para acceder al entorno.

9. Para ver la canalización funcionando, seleccione el trabajo en la página de Resumen de ejecución. Cuando se complete la ejecución, seleccione el vínculo Dirección URL de la aplicación de App Service en el paso Implementar aplicación web de Azure para ver la aplicación web implementada.

Personalización de la canalización

Para editar la canalización, seleccione el icono Más acciones situado en la esquina superior derecha de la página Resumen de ejecución y, a continuación, seleccione Editar canalización o seleccione Editar en la esquina superior derecha de la página de la canalización. Cada modificación que confirme en el repositorio inicia un nuevo proceso de pipeline de CI/CD.

Puede personalizar la canalización de varias maneras:

Uso de una versión específica de PHP

Se instalan varias versiones php en agentes de Ubuntu hospedados por Microsoft. Un vínculo simbólico en /usr/bin/php apunta a la versión de PHP actual, por lo que al ejecutar php, se ejecuta la versión establecida.

Para usar una versión php distinta de la predeterminada, puede apuntar el vínculo simbólico a la versión deseada mediante el update-alternatives comando . En la canalización de YAML, cambie el valor de la phpVersion variable a la versión que desee y use el siguiente fragmento de código:

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

Instalación de dependencias

Para usar Composer para instalar dependencias, incluya el siguiente fragmento de código en el archivo azure-pipelines.yml :

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

Si el archivo composer.json no está en el directorio raíz, puede usar el --working-dir argumento para especificar qué directorio usar. Por ejemplo, si composer.json está en la subcarpeta /pkgs, use composer install --no-interaction --working-dir=pkgs. También puede especificar una ruta de acceso absoluta mediante la variable del sistema integrada: --working-dir='$(System.DefaultWorkingDirectory)/pkgs'.

Prueba con PHPUnit

Para ejecutar pruebas con PHPUnit, agregue el siguiente fragmento de código al archivo azure-pipelines.yml :

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

Conservar los artefactos de PHP con el registro de compilación

Para guardar los artefactos de la compilación con el registro de compilación, incluya la tarea Archivar archivos en la canalización y, opcionalmente, personalice el valor de rootFolderOrFile para cambiar lo que incluye el archivo.

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

Contenido relacionado

• Implementación en App Service mediante Azure Pipelines
• Trabajos de implementación
• Plantillas de YAML en canalizaciones