Crie, teste e implante aplicativos PHP

Serviços de DevOps do Azure

Este artigo mostra como criar um pipeline no Azure Pipelines que cria um aplicativo Web PHP e o implanta no Serviço de Aplicativo do Azure. O Serviço de Aplicativo é um serviço baseado em HTTP para hospedagem de aplicativos Web, APIs REST e back-ends móveis. O pipeline usa integração contínua da fonte do GitHub e entrega contínua ao Serviço de Aplicativo para criar, testar e implantar automaticamente aplicativos PHP.

O Azure Pipelines cria seus projetos PHP sem que você precise configurar nenhuma infraestrutura. O PHP é pré-instalado em agentes hospedados pela Microsoft, juntamente com muitas bibliotecas comuns para versões do PHP. Você pode usar agentes Linux, macOS ou Windows para executar suas compilações. Para obter mais informações sobre quais versões do PHP estão pré-instaladas, consulte Software.

Pré-requisitos

• Sua própria bifurcação do projeto PHP GitHub de exemplo em https://github.com/Azure-Samples/php-docs-hello-world.

• Um aplicativo Web PHP criado para o projeto no Serviço de Aplicativo do Azure. Para criar rapidamente um aplicativo Web PHP, consulte Criar um aplicativo Web PHP no Serviço de Aplicativo do Azure. Você também pode usar seu próprio projeto PHP GitHub e aplicativo web.

Você também precisa dos seguintes pré-requisitos:

Exemplo de pipeline

O arquivo azure-pipelines.yml a seguir, baseado no modelo de pipeline PHP como Linux Web App no Azure, tem dois estágios, , Build e Deploy. O Build estágio instala o PHP 8.2 e, em seguida, executa tarefas para arquivar seus arquivos de projeto e publicar um artefato de construção ZIP em um pacote chamado drop.

O estágio é executado se o estágio for bem-sucedido e implanta o pacote no App Service usando a tarefa Azure Web App . Quando você usa o modelo PHP como Aplicativo Web Linux no Azure para criar seu pipeline, o pipeline gerado define e usa variáveis e outros valores com base em suas definições de configuração.

    - 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

Criar o pipeline YAML

Para criar e executar o pipeline de exemplo, execute as seguintes etapas:

1. No seu projeto do Azure DevOps, selecione Pipelines no menu de navegação esquerdo e, em seguida, selecione Novo pipeline ou Criar pipeline se este pipeline for o primeiro do projeto.

2. Na página Onde está seu código , selecione GitHub.

3. Na página Selecione um repositório , selecione seu repositório php-docs-hello-world bifurcado.

4. O Azure Pipelines reconhece o código como um aplicativo PHP e sugere vários modelos de pipeline na página Configurar seu pipeline . Para este exemplo, selecione PHP como Linux Web App no Azure.

5. Na tela seguinte, selecione sua assinatura do Azure e selecione Continuar. Esta ação cria uma conexão de serviço com seus recursos do Azure.

6. Na tela seguinte, selecione seu aplicativo Web do Azure e selecione Validar e configurar. O Azure Pipelines cria um arquivo de azure-pipelines.yml e o exibe no editor de pipeline YAML.

7. Na página Rever o seu pipeline YAML, reveja o código do seu pipeline. Quando estiver pronto, selecione Salvar e executar.

   

8. Na próxima tela, selecione Salvar e executar novamente para confirmar o novo arquivo azure-pipelines.yml no repositório e iniciar uma compilação de CI/CD.

   Observação

   Na primeira vez que o pipeline é executado, ele solicita permissão para acesso ao ambiente que cria. Selecione Permitir para conceder permissão para o pipeline aceder ao ambiente.

9. Para ver o seu pipeline em ação, selecione a tarefa na página Resumo da execução. Quando a execução for concluída, selecione o link URL do Aplicativo do Serviço de Aplicativo na etapa Implantar o Aplicativo Web do Azure para ver o aplicativo Web implantado.

Personalizar o fluxo de trabalho

Você pode editar o pipeline selecionando o ícone Mais ações no canto superior direito da página Resumo da execução e, em seguida, selecionando Editar pipeline ou selecionando Editar no canto superior direito da página do pipeline. Cada edição confirmada no repositório inicia uma nova execução de pipeline de CI/CD.

Você pode personalizar o pipeline de várias maneiras:

Usar uma versão específica do PHP

Várias versões do PHP são instaladas em agentes Ubuntu hospedados pela Microsoft. Um link simbólico em /usr/bin/php aponta para a versão atual do PHP, portanto, quando você executa php, a versão definida é executada.

Para usar uma versão do PHP diferente da padrão, você pode apontar o link simbólico para a versão desejada usando o update-alternatives comando. No pipeline do YAML, altere o phpVersion valor da variável para a versão desejada e use o seguinte trecho:

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

Instalar dependências

Para usar o Composer para instalar dependências, inclua o seguinte trecho no arquivo azure-pipelines.yml :

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

Se o arquivo composer.json não estiver no diretório raiz, você poderá usar o --working-dir argumento para especificar qual diretório usar. Por exemplo, se composer.json estiver na subpasta /pkgs, use composer install --no-interaction --working-dir=pkgs. Você também pode especificar um caminho absoluto usando a variável de sistema interna: --working-dir='$(System.DefaultWorkingDirectory)/pkgs'.

Teste com PHPUnit

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

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

Retenha os artefatos PHP com o registro de compilação

Para salvar os artefatos da compilação com o registro de compilação, inclua a tarefa Arquivos de Arquivo em seu pipeline e, opcionalmente, personalize o valor de rootFolderOrFile para alterar o que o arquivo inclui.

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

Conteúdo relacionado

• Implementar no Serviço de Aplicações com o Azure Pipelines
• Trabalhos de implementação
• Modelos YAML em pipelines