Usar o Azure Pipelines para criar e implantar um aplicativo Web Python no Serviço de Aplicativo do Azure

Serviços de DevOps do Azure

Use o Azure Pipelines para integração contínua e entrega contínua (CI/CD) para criar e implantar um aplicativo Web Python no Serviço de Aplicativo do Azure no Linux. Seu pipeline cria e implanta automaticamente seu aplicativo Web Python no Serviço de Aplicativo sempre que há uma confirmação no repositório.

Neste artigo, vai aprender a:

• Criar uma aplicação Web no Serviço de Aplicações do Azure.
• Crie um projeto no Azure DevOps.
• Conecte seu projeto DevOps ao Azure.
• Crie um pipeline específico do Python.
• Execute o pipeline para criar e implantar seu aplicativo Web no Serviço de Aplicativo.

Pré-requisitos

• Uma subscrição do Azure. Se não tiver uma subscrição, crie uma conta gratuita.
• Uma conta GitHub. Se você não tiver um, crie um gratuitamente.
• Uma organização dos Serviços de DevOps do Azure. Crie um gratuitamente.

Criar um repositório para o código do seu aplicativo

Fork o repositório de exemplo em https://github.com/Microsoft/python-sample-vscode-flask-tutorial sua conta do GitHub.

Em seu host local, clone seu repositório GitHub. Use o seguinte comando, substituindo <repository-url> pela URL do seu repositório bifurcado.

git clone <repository-url>

Teste seu aplicativo localmente

Crie e execute o aplicativo localmente para garantir que ele funcione.

1. Mude para a pasta do repositório clonado.

   cd python-sample-vscode-flask-tutorial
   

2. Compilar e executar a aplicação

   Linux

   python -m venv .env
   source .env/bin/activate
   pip install --upgrade pip
   pip install -r ./requirements.txt
   export set FLASK_APP=hello_app.webapp
   python3 -m flask run
   

   PowerShell

   py -m venv .env
   .env\scripts\activate
   pip install -r ./requirements.txt
   $env:FLASK_APP = "hello_app.webapp"
   flask run
   

3. Para visualizar o aplicativo, abra uma janela do navegador e vá para http://localhost:5000. Verifique se você vê o título Visual Studio Flask Tutorial.

4. Quando terminar, feche a janela do navegador e pare o servidor Flask com Ctrl+C.

Abra um Cloud Shell

1. Inicie sessão no Portal do Azure em https://portal.azure.com.

2. Abra a CLI do Azure selecionando o botão Cloud Shell na barra de ferramentas do portal.

   

3. O Cloud Shell aparece na parte inferior do navegador. Selecione Bash no menu suspenso.

   

4. Para lhe dar mais espaço para trabalhar, selecione o botão maximizar.

Criar um aplicativo Web do Serviço de Aplicativo do Azure

Crie seu aplicativo Web do Serviço de Aplicativo do Azure a partir do Cloud Shell no portal do Azure.

Gorjeta

Para colar no Cloud Shell, use Ctrl+Shift+V ou clique com o botão direito do mouse e selecione Colar no menu de contexto.

1. Clone seu repositório com o seguinte comando, substituindo <repository-url> pelo URL do seu repositório bifurcado.

   git clone <repository-url>
   

2. Altere o diretório para a pasta do repositório clonado, para que o az webapp up comando reconheça o aplicativo como um aplicativo Python.

   cd python-sample-vscode-flask-tutorial
   

3. Use o comando az webapp up para provisionar o Serviço de Aplicativo e fazer a primeira implantação do seu aplicativo. Substitua <your-web-app-name> por um nome exclusivo no Azure. Normalmente, você usa um nome pessoal ou da empresa junto com um identificador de aplicativo, como <your-name>-flaskpipelines. O URL do aplicativo se torna your-appservice.azurewebsites.net>.<

   az webapp up --name <your-web-app-name>
   

   A saída JSON do az webapp up comando mostra:

   {
     "URL": <your-web-app-url>,
     "appserviceplan": <your-app-service-plan-name>,
     "location": <your-azure-location>,
     "name": <your-web-app-name>,
     "os": "Linux",
     "resourcegroup": <your-resource-group>,
     "runtime_version": "python|3.11",
     "runtime_version_detected": "-",
     "sku": <sku>,
     "src_path": <repository-source-path>
   }
   

   Observe o URL e os runtime_version valores. Use o runtime_version arquivo YAML no pipeline. O URL é o URL do seu aplicativo Web. Você pode usá-lo para verificar se o aplicativo está em execução.

   Nota

   O comando az webapp up executa as seguintes ações:

   • Crie um grupo de recursos padrão.

   • Crie um plano padrão do Serviço de Aplicativo.

   • Crie um aplicativo com o nome especificado.

   • Zip implantar todos os arquivos do diretório de trabalho atual, com automação de compilação ativada.

   • Armazene os parâmetros em cache localmente no arquivo .azure/config para que você não precise especificá-los novamente ao implantar posteriormente com az webapp up ou outros az webapp comandos da pasta do projeto. Os valores armazenados em cache são usados automaticamente por padrão.

   Você pode substituir a ação padrão por seus próprios valores usando os parâmetros de comando. Para obter mais informações, consulte az webapp up.

4. O aplicativo python-sample-vscode-flask-tutorial tem um arquivo startup.txt que contém o comando de inicialização específico para o aplicativo Web. Defina a propriedade de configuração do aplicativo startup-file Web como startup.txt.

   1. Na saída do comando, copie az webapp up o resourcegroup valor.

   2. Digite o comando a seguir, usando o grupo de recursos e o nome do aplicativo.

   az webapp config set --resource-group <your-resource-group> --name <your-web-app-name> --startup-file startup.txt
   

   Quando o comando for concluído, ele mostrará a saída JSON que contém todas as definições de configuração para seu aplicativo Web.

5. Para ver o aplicativo em execução, abra um navegador e vá para o URL mostrado na saída do az webapp up comando. Se vir uma página genérica, aguarde alguns segundos até que o Serviço de Aplicação inicie e, em seguida, atualize a página. Verifique se você vê o título Visual Studio Flask Tutorial.

Criar um projeto de DevOps do Azure

Crie um novo projeto do Azure DevOps.

1. Num browser, aceda a dev.azure.com e inicie sessão.
2. Selecione a sua organização.
3. Crie um novo projeto selecionando Novo projeto ou Criar projeto se estiver criando o primeiro projeto na organização.
4. Insira um nome de projeto.
5. Selecione a Visibilidade do seu projeto.
6. Selecione Criar.

Criar uma conexão de serviço

Uma conexão de serviço permite que você crie uma conexão para fornecer acesso autenticado dos Pipelines do Azure para serviços externos e remotos. Para implantar em seu aplicativo Web do Serviço de Aplicativo do Azure, crie uma conexão de serviço com o grupo de recursos que contém o aplicativo Web.

1. Na página do projeto, selecione Configurações do projeto.

   

2. Selecione Conexões de serviço na seção Pipelines do menu.

3. Selecione Criar ligação de serviço.

4. Selecione Azure Resource Manager e selecione Next.

   

5. Selecione seu método de autenticação e selecione Avançar.

6. Na caixa de diálogo Nova conexão de serviço do Azure, insira as informações específicas do método de autenticação selecionado. Para obter mais informações sobre métodos de autenticação, consulte Conectar-se ao Azure usando uma conexão de serviço do Azure Resource Manager.

   Por exemplo, se você estiver usando um método de autenticação de Identidade de Carga de Trabalho (automática) ou de entidade de serviço (automática), insira as informações necessárias.

   

   Campo	Descrição
   Nível de âmbito	Selecione a Subscrição.
   Subscrição	Seu nome de assinatura do Azure.
   Grupo de recursos	O nome do grupo de recursos que contém seu aplicativo Web.
   Nome da conexão de serviço	Um nome descritivo para a conexão.
   Conceder permissões de acesso a todos os pipelines	Selecione esta opção para conceder acesso a todos os pipelines.

7. Selecione Guardar.

A nova conexão aparece na lista Conexões de serviço e está pronta para uso em seu Pipeline do Azure.

Criar um pipeline

Crie um pipeline para criar e implantar seu aplicativo Web Python no Serviço de Aplicativo do Azure. Para entender os conceitos de pipeline, assista:

1. No menu de navegação esquerdo, selecione Pipelines.

   

2. Selecione Criar Pipeline.

   

3. Na caixa de diálogo Onde está o código, selecione GitHub. Você pode ser solicitado a entrar no GitHub.

   

4. Na tela Selecione um repositório, selecione o repositório de exemplo bifurcado.

   

5. Você pode ser solicitado a inserir sua senha do GitHub novamente como uma confirmação.

6. Se a extensão Azure Pipelines não estiver instalada no GitHub, o GitHub solicitará que você instale a extensão Azure Pipelines .

   

   Nesta página, role para baixo até a seção Acesso ao repositório , escolha se deseja instalar a extensão em todos os repositórios ou apenas nos selecionados e, em seguida, selecione Aprovar e instalar.

   

7. Na caixa de diálogo Configurar seu pipeline, selecione Python para Linux Web App no Azure.

8. Selecione sua assinatura do Azure e selecione Continuar.

9. Se estiver a utilizar o seu nome de utilizador e palavra-passe para se autenticar, abre-se um browser para iniciar sessão na sua conta Microsoft.

10. Selecione o nome do aplicativo Web na lista suspensa e selecione Validar e configurar.

O Azure Pipelines cria um arquivo de azure-pipelines.yml e o exibe no editor de pipelines YAML. O arquivo de pipeline define seu pipeline de CI/CD como uma série de estágios, trabalhos e etapas, onde cada etapa contém os detalhes de diferentes tarefas e scripts. Dê uma olhada no pipeline para ver o que ele faz. Certifique-se de que todas as entradas padrão são apropriadas para o seu código.

Arquivo de pipeline YAML

A explicação a seguir descreve o arquivo de pipeline YAML. Para saber mais sobre o esquema de arquivo YAML do pipeline, consulte Referência do esquema YAML.

O exemplo completo de arquivo YAML pipeline é mostrado abaixo:

trigger:
- main

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureServiceConnectionId: '<GUID>'

  # Web app name
  webAppName: '<your-webapp-name>'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

  # Environment name
  environmentName: '<your-webapp-name>'

  # Project root folder. Point to the folder containing manage.py file.
  projectRoot: $(System.DefaultWorkingDirectory)

  pythonVersion: '3.11'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: BuildJob
    pool:
      vmImage: $(vmImageName)
    steps:
    - task: UsePythonVersion@0
      inputs:
        versionSpec: '$(pythonVersion)'
      displayName: 'Use Python $(pythonVersion)'

    - script: |
        python -m venv antenv
        source antenv/bin/activate
        python -m pip install --upgrade pip
        pip install setup
        pip install -r requirements.txt
      workingDirectory: $(projectRoot)
      displayName: "Install requirements"

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(projectRoot)'
        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: UsePythonVersion@0
            inputs:
              versionSpec: '$(pythonVersion)'
            displayName: 'Use Python version'

          - task: AzureWebApp@1
            displayName: 'Deploy Azure Web App : $(webAppName)'
            inputs:
              azureSubscription: $(azureServiceConnectionId)
              appName: $(webAppName)
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip

Variáveis

A variables seção contém as seguintes variáveis:

variables:
# Azure Resource Manager connection created during pipeline creation
azureServiceConnectionId: '<GUID>'

# Web app name
webAppName: '<your-webapp-name>'

# Agent VM image name
vmImageName: 'ubuntu-latest'

# Environment name
environmentName: '<your-webapp-name>'

# Project root folder.
projectRoot: $(System.DefaultWorkingDirectory)

# Python version: 3.11. Change this to match the Python runtime version running on your web app.
pythonVersion: '3.11'

Variável	Descrição
azureServiceConnectionId	A ID ou o nome da conexão de serviço do Azure Resource Manager.
webAppName	O nome do aplicativo Web do Serviço de Aplicativo do Azure.
vmImageName	O nome do sistema operacional a ser usado para o agente de compilação.
environmentName	O nome do ambiente usado no estágio de implantação. O ambiente é criado automaticamente quando o trabalho de palco é executado.
projectRoot	A pasta raiz que contém o código do aplicativo.
pythonVersion	A versão do Python a ser usada nos agentes de compilação e implementação.

Fase de construção

O estágio de compilação contém um único trabalho que é executado no sistema operacional definido na variável vmImageName.

  - job: BuildJob
    pool:
      vmImage: $(vmImageName)

O trabalho contém várias etapas:

1. A tarefa UsePythonVersion seleciona a versão do Python a ser usada. A versão é definida na pythonVersion variável.

      - task: UsePythonVersion@0
         inputs:
           versionSpec: '$(pythonVersion)'
           displayName: 'Use Python $(pythonVersion)'
   

2. Esta etapa usa um script para criar um ambiente Python virtual e instalar as dependências do aplicativo contidas no requirements.txt parâmetro The workingDirectory especifica o local do código do aplicativo.

     - script: |
          python -m venv antenv
          source antenv/bin/activate
          python -m pip install --upgrade pip
          pip install setup
          pip install  -r ./requirements.txt
        workingDirectory: $(projectRoot)
        displayName: "Install requirements"
   

3. A tarefa ArchiveFiles cria o arquivo .zip que contém o aplicativo Web. O .zip arquivo é carregado no pipeline como o artefato chamado drop. O .zip arquivo é usado no estágio de implantação para implantar o aplicativo no aplicativo Web.

      - task: ArchiveFiles@2
        displayName: 'Archive files'
        inputs:
          rootFolderOrFile: '$(projectRoot)'
          includeRootFolder: false
          archiveType: zip
          archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
          replaceExistingArchive: true
   
      - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        displayName: 'Upload package'
        artifact: drop
   

   Parâmetro	Descrição
   rootFolderOrFile	O local do código do aplicativo.
   includeRootFolder	Indica se a pasta raiz deve ser incluída no arquivo .zip . Defina esse parâmetro como false caso contrário, o conteúdo do arquivo .zip será colocado em uma pasta chamada s e o Serviço de Aplicativo no contêiner Linux não conseguirá encontrar o código do aplicativo.
   archiveType	O tipo de arquivo a criar. Definido como zip.
   archiveFile	O local do arquivo de .zip a ser criado.
   replaceExistingArchive	Indica se um arquivo existente deve ser substituído se o arquivo já existir. Definido como true.
   upload	A localização do ficheiro de .zip a carregar.
   artifact	O nome do artefato a ser criado.

Fase de implementação

O estágio de implantação será executado se o estágio de compilação for concluído com êxito. As seguintes palavras-chave definem esse comportamento:

  dependsOn: Build
  condition: succeeded()

O estágio de implantação contém um único trabalho de implantação configurado com as seguintes palavras-chave:

  - deployment: DeploymentJob
    pool:
      vmImage: $(vmImageName)
    environment: $(environmentName)

Palavra-chave	Descrição
deployment	Indica que o trabalho é um trabalho de implantação direcionado a um ambiente.
pool	Especifica o pool de agentes de implantação. O pool de agentes padrão se o nome não for especificado. A vmImage palavra-chave identifica o sistema operacional para a imagem da máquina virtual do agente
environment	Especifica o ambiente para implantação. O ambiente é criado automaticamente em seu projeto quando o trabalho é executado.

A strategy palavra-chave é usada para definir a estratégia de implantação. A runOnce palavra-chave especifica que o trabalho de implantação é executado uma vez. A deploy palavra-chave especifica as etapas a serem executadas no trabalho de implantação.

  strategy:
    runOnce:
      deploy:
        steps:

Na steps calha estão:

1. Use a tarefa UsePythonVersion para especificar a versão do Python a ser usada no agente. A versão é definida na pythonVersion variável.

    - task: UsePythonVersion@0
      inputs:
        versionSpec: '$(pythonVersion)'
      displayName: 'Use Python version'
   

2. Implante o aplicativo Web usando o AzureWebApp@1. Esta tarefa implanta o artefato drop de pipeline em seu aplicativo Web.

   - task: AzureWebApp@1
      displayName: 'Deploy Azure Web App : <your-web-app-name>'
      inputs:
         azureSubscription: $(azureServiceConnectionId)
         appName: $(webAppName)
         package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
   

   Parâmetro	Descrição
   azureSubscription	A ID de conexão de serviço do Azure Resource Manager ou o nome a ser usado.
   appName	o nome da aplicação Web.
   package	O local do arquivo de .zip a ser implantado.

   Além disso, como o repositório python-vscode-flask-tutorial contém o mesmo comando de inicialização em um arquivo chamado startup.txt, você pode especificar esse arquivo adicionando o parâmetro: startUpCommand: 'startup.txt'.

Executar o pipeline

Agora você está pronto para experimentá-lo!

1. No editor, selecione Salvar e executar.

2. Na caixa de diálogo Salvar e executar, adicione uma mensagem de confirmação e selecione Salvar e executar.

   Você pode observar o pipeline enquanto ele é executado selecionando o resumo Estágios ou Trabalhos no pipeline run.

   

   Há marcas de seleção verdes ao lado de cada estágio e trabalho à medida que ele é concluído com êxito. Se ocorrerem erros, eles serão exibidos no resumo ou nas etapas do trabalho.

   

   Você pode retornar rapidamente ao editor YAML selecionando os pontos verticais no canto superior direito da página Resumo e selecionando Editar pipeline:

   

3. No trabalho de implantação, selecione a tarefa Implantar Aplicativo Web do Azure para exibir sua saída. Para visitar o site implantado, mantenha pressionada a tecla Ctrl e selecione o URL após App Service Application URL.

   Se você estiver usando o aplicativo de exemplo, o aplicativo deverá aparecer da seguinte maneira:

   

Importante

Se seu aplicativo falhar devido a uma dependência ausente, seu arquivo de requirements.txt não foi processado durante a implantação. Esse comportamento acontece se você criou o aplicativo Web diretamente no portal em vez de usar o comando, az webapp up como mostrado neste artigo.

O az webapp up comando define especificamente a ação SCM_DO_BUILD_DURING_DEPLOYMENT de compilação como true. Se você provisionou o serviço do aplicativo por meio do portal, essa ação não será definida automaticamente.

As etapas a seguir definem a ação:

1. Abra o portal do Azure, selecione o Serviço de Aplicativo e selecione Configuração.
2. Na guia Configurações do aplicativo, selecione Nova configuração do aplicativo.
3. No pop-up exibido, defina Nome como SCM_DO_BUILD_DURING_DEPLOYMENT, defina Valor como truee selecione OK.
4. Selecione Salvar na parte superior da página Configuração .
5. Executar o pipeline novamente. Suas dependências devem ser instaladas durante a implantação.

Acionar uma execução de pipeline

Para acionar uma execução de pipeline, confirme uma alteração no repositório. Por exemplo, você pode adicionar um novo recurso ao aplicativo ou atualizar as dependências do aplicativo.

1. Vá para o repositório GitHub.
2. Faça uma alteração no código, como alterar o título do aplicativo.
3. Confirme a alteração no repositório.
4. Vá para o pipeline e verifique se uma nova execução foi criada.
5. Quando a execução for concluída, verifique se a nova compilação foi implantada em seu aplicativo Web.
   1. No portal do Azure, vá para seu aplicativo Web.
   2. Selecione Centro de Implantação e selecione a guia Logs .
   3. Verifique se a nova implantação está listada.

Considerações para Django

Você pode usar o Azure Pipelines para implantar aplicativos Django no Serviço de Aplicativo do Azure no Linux se estiver usando um banco de dados separado. Não é possível usar um banco de dados SQLite, porque o Serviço de Aplicativo bloqueia o arquivo db.sqlite3 , impedindo leituras e gravações. Esse comportamento não afeta um banco de dados externo.

Conforme descrito em Configurar aplicativo Python no Serviço de Aplicativo - Processo de inicialização de contêiner, o Serviço de Aplicativo procura automaticamente um arquivo de wsgi.py no código do aplicativo, que normalmente contém o objeto do aplicativo. Se você quiser personalizar o comando de inicialização de alguma forma, use o startUpCommand AzureWebApp@1 parâmetro na etapa do seu arquivo de pipeline YAML, conforme descrito na seção anterior.

Ao usar o Django, você normalmente deseja migrar os modelos de dados usando manage.py migrate depois de implantar o código do aplicativo. Você pode adicionar startUpCommand com um script pós-implantação para essa finalidade. Por exemplo, aqui está a startUpCommand propriedade na tarefa AzureWebApp@1.

  - task: AzureWebApp@1
      displayName: 'Deploy Azure Web App : $(webAppName)'
      inputs:
        azureSubscription: $(azureServiceConnectionId)
        appName: $(webAppName)
        package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
        startUpCommand: 'python manage.py migrate'

Executar testes no agente de compilação

Como parte do processo de compilação, convém executar testes no código do aplicativo. Os testes são executados no agente de compilação, portanto, você precisa instalar suas dependências em um ambiente virtual no agente de compilação. Após a execução dos testes, exclua o ambiente virtual antes de criar o arquivo de .zip para implantação. Os seguintes elementos de script ilustram esse processo. Coloque-os antes da ArchiveFiles@2 tarefa no arquivo azure-pipelines.yml . Para obter mais informações, consulte Executar scripts entre plataformas.

# The | symbol is a continuation character, indicating a multi-line script.
# A single-line script can immediately follow "- script:".
- script: |
    python -m venv .env
    source .env/bin/activate
    pip install setuptools
    pip install -r requirements.txt

  # The displayName shows in the pipeline UI when a build runs
  displayName: 'Install dependencies on build agent'

- script: |
    # Put commands to run tests here
    displayName: 'Run tests'

- script: |
    echo Deleting .env
    deactivate
    rm -rf .env
  displayName: 'Remove .env before zip'

Você também pode usar uma tarefa como PublishTestResults@2 para publicar os resultados do teste em seu pipeline. Para obter mais informações, consulte Build Python apps - Run tests.

Clean up resources (Limpar recursos)

Para evitar incorrer em encargos nos recursos do Azure criados neste tutorial:

• Exclua o projeto que você criou. A exclusão do projeto exclui o pipeline e a conexão de serviço.

• Exclua o grupo de recursos do Azure que contém o Serviço de Aplicativo e o Plano do Serviço de Aplicativo. No portal do Azure, vá para o grupo de recursos, selecione Excluir grupo de recursos e siga os prompts.

• Exclua a conta de armazenamento que mantém o sistema de arquivos para o Cloud Shell. Feche o Cloud Shell e vá para o grupo de recursos que começa com cloud-shell-storage-, selecione Excluir grupo de recursos e siga as instruções.

Próximos passos

• Personalizar aplicativos Python no Azure Pipelines
• Configurar o aplicativo Python no Serviço de Aplicativo