Crie e teste aplicativos PHP

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

Produto	Requisitos
Azure DevOps	- Um projeto Azure DevOps. - Capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar um nível gratuito. - Conhecimentos básicos de YAML e Azure Pipelines. Para obter mais informações, consulte Crie o seu primeiro pipeline. - Permissões:      - Para criar um pipeline: você deve estar no grupo Colaboradores e o grupo precisa ter a permissão Criar pipeline de compilação definida como Permitir. Os membros do grupo Administradores de Projeto podem gerenciar pipelines.     - Para criar conexões de serviço: Deve ter a função de Administrador ou Criador para conexões de serviço.
GitHub	- Uma conta GitHub. - Uma ligação de serviço do GitHub para autorizar o Azure Pipelines.
Azure	Uma 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 uma canalização

1. Entre na sua organização do Azure DevOps e vá para o seu projeto.

2. Vá para pipelines e selecione Novo pipeline.

3. Selecione seu local de origem (GitHub, Azure Repos Git, Bitbucket Cloud ou outros repositórios Git).

4. Selecione o repositório onde seu código está localizado.

5. Selecione PHP na guia Configurar .

6. Verifique se a versão do PHP é 8.3.

7. Examine a sua nova linha de processamento. Quando estiver pronto, selecione Salvar e executar.

   

8. Você será solicitado a confirmar um novo arquivo azure-pipelines.yml no seu repositório. Selecione Salvar e executar novamente.

   Para observar o pipeline em ação, selecione a tarefa de build.

   Agora você tem um pipeline YAML (azure-pipelines.yml) em funcionamento 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.

Implantar 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.

Este pipeline tem dois estágios: Construir e Implementar. 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 de Desenvolvimento, o pacote é implementado drop no Serviço de Aplicações do Azure como uma aplicação 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-22.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 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 aponta para a versão PHP atualmente definida. Assim, quando executar php, a versão definida será 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-22.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 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 guardar os artefatos desta compilação junto com o registo de compilação, adicione o seguinte trecho ao seu arquivo azure-pipelines.yml. 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 numa subpasta em vez do diretório raiz, você pode usar o argumento --working-dir para informar ao Composer 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'