Crie e teste aplicativos PHP

Artigo
05/21/2024

Serviços de DevOps do Azure

Use a integração contínua e a entrega contínua (CI/CD) 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 no Serviço de Aplicativo do Azure e como configurar seu ambiente.

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

Pré-requisitos

Certifique-se de que tem os itens seguintes:

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

Uma conta do Azure. Se não tiver uma, pode criar uma gratuitamente.

Gorjeta

Se você é 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ê vai implantar no Serviço de Aplicativo do Azure, precisa ter um aplicativo Web criado.

Obter o código

Se você já tiver um aplicativo no GitHub que deseja implantar, poderá criar um pipeline para esse código. Mas, se você é um novo usuário, você pode 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 sua organização do Azure DevOps e vá para o seu projeto.
Vá para pipelines e selecione Novo pipeline.
Selecione seu local de origem (GitHub, Azure Repos Git, Bitbucket Cloud ou outros repositórios Git).
Selecione o repositório onde seu código está localizado.
Selecione PHP na guia Configurar.
Verifique se a versão do PHP é 8.3.
Examine seu novo pipeline. Quando estiver pronto, selecione Salvar e executar.
Você será solicitado a confirmar um novo arquivo de azure-pipelines.yml no repositório. Selecione Salvar e executar novamente.

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

Agora você tem um pipeline YAML (azure-pipelines.yml) funcional em seu repositório que está pronto para você 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 aprender algumas das maneiras mais comuns de personalizar seu pipeline.

Implementar no Serviço de Aplicações

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 baseado em HTTP para hospedar aplicativos Web, APIs REST e back-ends móveis.

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

Esse pipeline tem dois estágios: Build e Deploy. No estágio de compilação, 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 Implantação, o pacote é implantado drop 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-latest'
  # 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 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 por versão do PHP. Você pode usar agentes Linux, macOS ou Windows para executar suas compilações. Para obter mais informações e as versões exatas do PHP que são pré-instaladas, consulte Agentes hospedados pela Microsoft.

No agente Ubuntu hospedado pela Microsoft, várias versões do PHP são instaladas. Um link simbólico em /usr/bin/php pontos para a versão PHP atualmente definida, para que quando você executar php, a versão definida seja executada.

Para usar uma versão do PHP diferente do padrão, o link simbólico pode ser apontado para essa versão usando a update-alternatives ferramenta. Defina a versão do PHP desejada adicionando o seguinte trecho ao seu azure-pipelines.yml arquivo e altere o valor da variável phpVersion .

pool:
  vmImage: 'ubuntu-latest'

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 seguinte trecho ao arquivo azure-pipelines.yml .

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

Teste com phpunit

Para executar testes com phpunit, adicione o seguinte trecho ao seu azure-pipelines.yml arquivo.

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

Mantenha o aplicativo PHP com o registro de compilação

Para salvar os artefatos dessa compilação com o registro de compilação, adicione o seguinte trecho ao seu azure-pipelines.yml arquivo. Opcionalmente, personalize o valor de rootFolderOrFile para alterar o que está incluído no arquivo.

- 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 --working-dir argumento para dizer ao compositor qual diretório usar. Por exemplo, se o seu 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 de sistema internas:

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

Partilhar via