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

Serviços do Azure DevOps

Este tutorial mostra como usar 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 houver uma confirmação para o repositório de código do aplicativo.

Neste tutorial, você:

Para entender mais sobre os conceitos do Azure Pipelines, assista ao seguinte vídeo:

Pré-requisitos

$AGENT_TOOLSDIRECTORY/
    Python/
        {version number}/
            {platform}/
                {tool files}
            {platform}.complete

$AGENT_TOOLSDIRECTORY/
    Python/
        3.11.4/
            x64/
                {python files}
            x64.complete

Preparar o aplicativo de exemplo

1. Faça um fork do repositório de exemplo em https://github.com/Microsoft/python-sample-vscode-flask-tutorial para sua conta do GitHub.

2. Clone sua bifurcação em seu computador local usando git clone <your-forked-repository-url>.git.

3. Vá para o clone local usando cd python-sample-vscode-flask-tutoriale compile e execute o aplicativo localmente para garantir que ele funcione.

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

4. Para testar o aplicativo, acesse http://localhost:5000 uma janela do navegador e verifique se você vê o título do Tutorial do Flask do Visual Studio.

5. Feche a janela do navegador e interrompa o servidor Flask usando Ctrl+C.

Criar e implantar o aplicativo Web do Serviço de Aplicativo

Crie seu aplicativo Web do Serviço de Aplicativo do Azure usando o Cloud Shell no portal do Azure. Para usar o Cloud Shell, entre no portal do Azure e selecione o botão Cloud Shell na barra de ferramentas.

O Cloud Shell será exibido na parte inferior do navegador. Verifique se o Bash está selecionado como o ambiente no menu suspenso. Você pode maximizar a janela do Cloud Shell para dar a si mesmo mais espaço.

Criar e implantar o aplicativo Web

1. No Cloud Shell, clone seu repositório bifurcado no Azure com o comando a seguir, substituindo <your-forked-repository-url> pela URL do repositório bifurcado.

   git clone <your-forked-repository-url>
   

2. Altere o diretório para a pasta do repositório clonado.

   cd python-sample-vscode-flask-tutorial
   

3. Execute o comando az webapp up para provisionar o aplicativo Web do Serviço de Aplicativo e fazer a primeira implantação. Use o --name <your-web-app-name> parâmetro para atribuir um nome exclusivo no Azure, como um nome pessoal ou de empresa, juntamente com um identificador de aplicativo, como --name <your-name>-flaskpipelines. A execução az webapp up sem parâmetros atribui um nome de aplicativo Web gerado aleatoriamente que é exclusivo no Azure.

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

O az webapp up comando reconhece o aplicativo como um aplicativo Python e executa as seguintes ações:

1. Cria um grupo de recursos padrão.
2. Cria um plano padrão do Serviço de Aplicativo.
3. Cria um aplicativo Web com o nome atribuído. O aplicativo URL é <your-web-app-name>.azurewebsites.net.
4. Implanta todos os arquivos do diretório de trabalho atual em um arquivo zip, com a automação de build habilitada.
5. Armazena em cache os parâmetros localmente no arquivo .azure/config para que você não precise especificá-los novamente ao implantar da pasta do projeto com ou outros az webapp upaz webapp comandos. Os comandos usam os valores armazenados em cache automaticamente por padrão.

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

O az webapp up comando produz a seguinte saída JSON para o aplicativo Web de exemplo:

{
  "URL": <your-web-app-url>,
  "appserviceplan": <your-app-service-plan-name>,
  "location": <your-azure-region>,
  "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>
}

Registre os URLresourcegroupvalores e runtime_version os valores a serem usados posteriormente neste tutorial.

Definir o comando de inicialização

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 inserindo o comando a startup.txt seguir, usando o grupo de recursos e os nomes do aplicativo Web.

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

Quando o comando for concluído, a saída JSON mostrará todas as configurações do aplicativo Web.

Para ver o aplicativo em execução, abra um navegador e acesse o URL exibido na saída do comando az webapp up. Se for exibida uma página genérica, aguarde alguns segundos para que o Serviço de Aplicativo seja iniciado e atualize a página. Verifique se você vê o título do Tutorial do Flask do Visual Studio.

Conectar seu projeto do Azure DevOps à sua assinatura do Azure

Para usar o Azure Pipelines para implantar em seu aplicativo Web do Serviço de Aplicativo do Azure, você precisa conectar seu projeto do Azure DevOps aos recursos do Azure.

az ad sp create-for-rbac --display-name <service-principal-name> --role contributor --scopes /subscriptions/<your-subscription-id>/resourceGroups/<your-resource-group>

{
  "appId": "<client GUID>",
  "displayName": "<service-principal-name">,
  "password": "<password-string>",
  "tenant": "<tenant GUID>"
  ...
}

Criar uma conexão de serviço

Uma conexão de serviço fornece acesso autenticado do Azure Pipelines a 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 para seu aplicativo Web.

A nova conexão aparece na lista de conexões de serviço e está pronta para ser usada em seu pipeline.

Criar um pipeline

Crie um pipeline para compilar e implantar seu aplicativo Web Python no Serviço de Aplicativo do Azure.

Arquivo de pipeline YAML

Na página Examinar o YAML do pipeline , examine o pipeline para ver o que ele faz. Verifique se todas as entradas padrão são apropriadas para seu código. Para saber mais sobre o esquema de arquivo YAML do pipeline, consulte a referência de esquema YAML.

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 setuptools
        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

trigger:
- main

variables:
  # Azure Resource Manager connection created during pipeline creation
  azureServiceConnectionId: '<your-service-connection-name>'

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

  # Environment name
  environmentName: '<your-web-app-name>'

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

  # Python version: 
  pythonVersion: '<your-python-version>'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: BuildJob
pool:
      name: '<your-pool-name>'
      demands: python
    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 -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

    - task: PublishBuildArtifacts@1
      inputs:
        PathtoPublish: '$(Build.ArtifactStagingDirectory)'
        ArtifactName: 'drop'
        publishLocation: 'Container'

- stage: Deploy
  displayName: 'Deploy Web App'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: DeploymentJob
    pool:
      name: '<your-pool-name'
    environment: $(environmentName)
    strategy:
      runOnce:
        deploy:
          steps:

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

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

Variáveis

A variables seção no início do arquivo YAML define as seguintes variáveis:

Estágios de build e implantação

O pipeline consiste em estágios de build e implantação.

Fase de construção

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

  - job: BuildJob
    pool:
      name: <your-pool-name>
      demands: python

O trabalho contém várias etapas:

1. Primeiro, a tarefa UsePythonVersion seleciona a versão do Python a ser usada, conforme definido na pythonVersion variável.

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

2. A próxima etapa usa um script que cria um ambiente virtual do Python e instala as dependências do aplicativo.requirements.txt O workingDirectory parâmetro 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 setuptools
           pip install  -r ./requirements.txt
         workingDirectory: $(projectRoot)
         displayName: "Install requirements"
   

3. A tarefa ArchiveFiles cria um arquivo ZIP que contém o aplicativo Web compilado.

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

   Os parâmetros são definidos da seguinte maneira:

   Parâmetro	Descrição
   rootFolderOrFile	O local do código do aplicativo.
   includeRootFolder	Se a pasta raiz deve ser incluída no arquivo .zip . Defina como false. Se definido como true, o conteúdo do arquivo .zip será colocado em uma pasta nomeada e a tarefa não poderá encontrar o código do aplicativo.
   archiveType	O tipo de arquivo a ser criado. Defina como zip.
   archiveFile	O local do arquivo .zip a ser criado.
   replaceExistingArchive	Indica se um arquivo existente deve ser substituído se o arquivo já existir. Defina como true.

4. Em .zip seguida, o arquivo é carregado no pipeline como um artefato chamado drop. O estágio de implantação usa o arquivo .zip para implantar o aplicativo.

       - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
         displayName: 'Upload package'
         artifact: drop
   

   • O upload parâmetro define o local e o nome do arquivo .zip a ser carregado.
   • O artifact parâmetro define o nome do artefato criado como drop.

Etapa de implantação

O estágio de implantação será executado se o estágio de build for concluído com êxito. As dependsOn palavras-chave e as condition palavras-chave definem esse comportamento.

  dependsOn: Build
  condition: succeeded()

O estágio de implantação contém um único trabalho de implantação configurado da seguinte maneira.

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

  - deployment: DeploymentJob
    pool:
      name: <your-pool-name>
    environment: $(environmentName)

A strategy palavra-chave define a estratégia de implantação.

  strategy:
    runOnce:
      deploy:
        steps:

• A palavra-chave runOnce especifica que o trabalho de implantação é executado uma vez.
• A deploy palavra-chave especifica a steps execução no trabalho de implantação.

Neste steps estágio, execute as seguintes tarefas:

1. UsePythonVersion@0 seleciona a versão do Python a ser usada, como no estágio build.
2. AzureWebApp@1 implanta o aplicativo Web e o drop artefato ZIP.

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

• O azureSubscription parâmetro contém as azureServiceConnectionId variáveis de pipeline especificadas.
• Contém appName o valor da webAppName variável.
• Especifica package o nome e o local do arquivo .zip a ser implantado.

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

Executar o pipeline

Agora você está pronto para experimentar o pipeline.

1. No editor de pipeline, selecione Salvar e executar.

2. Na tela Salvar e executar , adicione uma mensagem de confirmação se desejar e selecione Salvar e executar.

   Você pode assistir à execução do pipeline selecionando os Estágios ou Trabalhos na página Resumo do pipeline. Cada trabalho e estágio exibem uma marca de seleção verde conforme ela é concluída com êxito. Se ocorrerem erros, eles aparecerão no resumo ou nas etapas de trabalho.

   

   Você pode retornar rapidamente ao editor yaml selecionando os pontos verticais no canto superior direito na 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.

   

4. Na saída, selecione a URL após a URL do Aplicativo do Serviço de Aplicativo. O aplicativo deve aparecer da seguinte maneira:

   

Disparar uma execução de pipeline

Esse pipeline é definido para ser executado sempre que uma alteração faz check-in no repositório de código. Para disparar 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 para seu aplicativo.
2. Faça uma alteração no código, como alterar o título do aplicativo.
3. Confirme a alteração.
4. Vá para o pipeline e verifique se uma nova execução foi criada e está em execução.
5. Quando a execução for concluída, verifique se a alteração foi implantada em seu aplicativo Web.
6. No portal do Azure, acesse seu aplicativo Web e selecione o Centro de Implantação no menu de navegação à esquerda.
7. Selecione a guia Logs e verifique se a nova implantação está listada.

Implantar aplicativos Django no Serviço de Aplicativo

Você pode usar o Azure Pipelines para implantar aplicativos Django no Serviço de Aplicativo no Linux se estiver usando um banco de dados separado. Você não pode 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 bancos de dados externos.

Conforme explicado no processo de inicialização do contêiner, o Serviço de Aplicativo procura automaticamente um arquivo wsgi.py no código do aplicativo, que normalmente contém o objeto do aplicativo. Se você quiser personalizar o comando de inicialização, use o startUpCommand parâmetro na AzureWebApp@1 etapa do arquivo de pipeline YAML.

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 esta finalidade: Por exemplo, aqui está a propriedade startUpCommand 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 construçã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 de teste antes de criar o arquivo .zip para implantação.

Os elementos de script a seguir ilustram esse processo. Coloque-os antes da tarefa ArchiveFiles@2 no arquivo azure-pipelines.yml. Para obter mais informações, consulte Executar scripts multiplataforma.

# 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 no pipeline. Para obter mais informações, consulte Executar testes.

Limpar os recursos

Se você terminar de usar os recursos do Azure criados neste tutorial, exclua-os para evitar incorrer em encargos adicionais.

• Exclua o projeto do Azure DevOps 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 do Azure que mantém o sistema de arquivos do Cloud Shell. Feche o Cloud Shell e localize o grupo de recursos que começa com cloud-shell-storage-. Selecione Excluir grupo de recursos e siga os prompts.

Conteúdo relacionado

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