Criar e testar aplicativos PHP

Artigo
05/20/2024

Azure DevOps Services

Use a CI/CD (integração contínua e entrega contínua) do Azure Pipelines para criar, implantar e testar seus projetos php.

Saiba como criar um pipeline php, implantar um pipeline com um projeto de exemplo para o Serviço de Aplicativo do Azure e como configurar seu ambiente.

Para saber mais sobre o Serviço de Aplicativo do Azure, confira Criar um aplicativo Web PHP no Serviço de Aplicativo do Azure.

Pré-requisitos

Verifique se você tem o seguinte:

Uma conta do GitHub, na qual você pode criar um repositório. Crie um gratuitamente.
Uma organização do Azure DevOps. Crie um gratuitamente. Se sua equipe já tiver uma, verifique se você é um administrador do projeto do Azure DevOps que deseja usar.
Uma capacidade de executar pipelines em agentes hospedados pela Microsoft. Para usar agentes hospedados pela Microsoft, sua organização do Azure DevOps precisa ter acesso a trabalhos paralelos hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar uma concessão gratuita.

Uma conta do Azure. Se não tiver uma, poderá criá-la gratuitamente.

Dica

Se você for novo nisso, a maneira mais fácil de começar é usar o mesmo endereço de email que o proprietário da organização do Azure Pipelines e da assinatura do Azure.

Se você quiser implantar no Serviço de Aplicativo do Azure, precisará ter um aplicativo Web criado.

Obter o código

Se já tiver um aplicativo no GitHub que deseja implantar, você poderá criar um pipeline para esse código. No entanto, se você for um novo usuário, poderá começar melhor usando nosso código de exemplo. Nesse caso, bifurque o seguinte repositório no GitHub:

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

Criar um pipeline

Entre na organização do Azure DevOps e acesse seu projeto.
Acesse os pipelines e selecione Novo pipeline.
Selecione o local de origem (GitHub, Azure Repos, Git, Bitbucket Cloud ou outros repositórios Git).
Selecione o repositório no qual seu código está localizado.
Selecione PHP na guia Configurar.
Confirme se a versão do PHP é 8.3.
Examine o seu novo pipeline. Ao final, selecione Salvar e executar.
Você será solicitado a confirmar um novo arquivo azure-pipelines.yml em seu repositório. Selecione Salvar e executar novamente.

Se você quiser inspecionar seu pipeline em ação, selecione o trabalho de compilação.

Agora você tem um pipeline YAML funcional (azure-pipelines.yml) em seu repositório que está pronto para personalizar!

Quando quiser fazer alterações no pipeline, selecione o pipeline na página Pipelines e edite o arquivo azure-pipelines.yml.

Leia mais para saber algumas das maneiras mais comuns de personalizar o pipeline.

Implantar no Serviço de Aplicativo

Use um pipeline para criar um aplicativo Web PHP e implantar no Serviço de Aplicativo do Azure. O Serviço de Aplicativo do Azure é um serviço com base em HTTP para hospedagem de aplicativos Web, APIs REST e back-ends móveis.

Você pode usar tarefas para arquivar seus arquivos, publicar um artefato de build e usar a tarefa aplicativo Web do Azure para implantar no Serviço de Aplicativo do Azure.

Esse pipeline tem dois estágios: Compilar e Implantar. No estágio Compilar, o PHP 8.3 é instalado com o Composer. Os arquivos do aplicativo são arquivados e carregados em um pacote chamado drop. Durante a fase Implantar, o pacote drop é implantado no Serviço de Aplicativo do Azure como um aplicativo 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

Configurar o ambiente de compilação

Use o Azure Pipelines para criar seus projetos PHP sem configurar a infraestrutura.

Usar uma versão específica do PHP

O PHP é pré-instalado em Agentes hospedados pela Microsoft, juntamente com muitas bibliotecas comuns de acordo com a versão PHP. Você pode usar agentes do Linux, macOS ou Windows para executar seus builds. Para obter mais informações e as versões exatas do PHP que são pré-instaladas, confira Agentes hospedados pela Microsoft.

No agente do Ubuntu hospedado pela Microsoft, várias versões do PHP são instaladas. Um symlink em pontos do /usr/bin/php é instalado na versão PHP definida no momento, para que, quando você executar php, a versão definida seja executada.

Para usar uma versão php diferente do padrão, o symlink pode ser apontado para essa versão usando a ferramenta update-alternatives. Defina a versão do PHP desejada adicionando o snippet a seguir ao arquivo azure-pipelines.yml e altere o valor da variável 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 dependências

Para usar o Composer para instalar dependências, adicione o snippet a seguir ao arquivo azure-pipelines.yml.

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

Testar com phpunit

Para executar testes com phpunit, adicione o snippet a seguir ao arquivo azure-pipelines.yml.

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

Reter o aplicativo PHP com o registro de build

Para salvar os artefatos desse build com o registro de build, adicione o snippet a seguir ao arquivo azure-pipelines.yml. Opcionalmente, personalize o valor de rootFolderOrFile para alterar o que está incluído no arquivo morto.

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

Usando um local de compositor personalizado

Se o composer.json estiver em uma subpasta em vez do diretório raiz, você poderá usar o argumento --working-dir para informar ao compositor qual diretório usar. Por exemplo, se o composer.json estiver dentro da subpasta pkgs

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

Você também pode especificar o caminho absoluto, usando as variáveis internas do sistema:

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

Compartilhar via