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

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 há uma confirmação no repositório de código do aplicativo.

Neste tutorial, você:

• Crie um aplicativo Web Python e carregue-o no Serviço de Aplicativo do Azure.
• Conecte seu projeto do Azure DevOps ao Azure.
• Crie um pipeline de compilação e implantação específico do Azure Pipelines Python para seu aplicativo.
• Execute o pipeline para criar, testar e implantar em seu aplicativo Web do Serviço de Aplicativo do Azure.
• Defina um gatilho para executar o pipeline sempre que você confirmar no repositório.

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

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: Você 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.

Preparar o aplicativo de exemplo

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

2. Clone seu garfo para sua máquina local usando git clone <your-forked-repository-url>.git.

3. Vá para seu clone local usando cd python-sample-vscode-flask-tutoriale crie 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, vá para http://localhost:5000 em uma janela do navegador e verifique se você vê o título Visual Studio Flask Tutorial.

5. Feche a janela do navegador e pare 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 aparece na parte inferior do navegador. Verifique se 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.

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.

Criar e implantar o aplicativo Web

1. No Cloud Shell, clone seu repositório bifurcado para o Azure com o seguinte comando, substituindo <your-forked-repository-url> pela URL do seu 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 da empresa junto 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 compilação habilitada.
5. Armazena em cache os parâmetros localmente no arquivo .azure/config para que você não precise especificá-los novamente ao implantar a partir da pasta do projeto com az webapp up ou outros az webapp comandos. Os comandos usam os valores armazenados em cache automaticamente por padrão.

Você pode substituir as ações padrão por 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 URLvalores , resourcegroupe para runtime_version usar 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 startup.txt inserindo o seguinte comando, usando seus nomes de grupo de recursos e aplicativos 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 definições de configuração para seu aplicativo Web.

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.

Conecte 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 seus recursos do Azure.

Criar uma conexão de serviço

Uma conexão de serviço fornece 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 do seu aplicativo Web.

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

2. Em Configurações do projeto, selecioneConexões de serviço>

3. Na página Conexões de serviço , selecione Nova conexão de serviço ou Criar conexão de serviço se essa conexão de serviço for a primeira do projeto.

   

4. Na tela Nova conexão de serviço , selecione Azure Resource Manager e selecione Avançar.

   

5. Na tela Nova conexão de serviço do Azure , selecione seu tipo de Identidade. Este exemplo usa o registro de aplicativo (automático), que é recomendado. 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.

6. Em Credencial, selecione Federação de identidades de carga de trabalho (automática).

7. Preencha os seguintes campos:

   • Nível de escopo: Selecione Assinatura.
   • Subscrição: selecione a sua subscrição do Azure.
   • Grupo de recursos: selecione o grupo de recursos que contém seu aplicativo Web.
   • Nome da Conexão de Serviço: insira um nome descritivo para a conexão.
   • Conceder permissões de acesso a todos os pipelines: marque esta caixa de seleção para conceder acesso a todos os pipelines no projeto.

8. Selecione Guardar.

   

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

Criar um fluxo de trabalho

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

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

2. Na página Pipelines , selecione Novo pipeline ou Criar pipeline se esse pipeline for o primeiro do projeto.

   

3. Na tela Onde está seu código , selecione GitHub. Você pode ser solicitado a entrar no GitHub.

   

4. Na tela Selecione um repositório , selecione seu repositório de exemplo bifurcado. O GitHub pode solicitar que você insira sua senha do GitHub novamente ou instale o aplicativo GitHub do Azure Pipelines . Siga as instruções na tela para instalar o aplicativo. Para obter mais informações, consulte Autenticação de aplicativo GitHub.

   

5. Na página Configurar seu pipeline , selecione Python para Linux Web App no Azure.

6. Na tela seguinte, selecione sua assinatura do Azure e selecione Continuar.

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

Arquivo de pipeline YAML

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

O arquivo de pipeline YAML de exemplo completo a seguir 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. O código YAML gerado preenche automaticamente os espaços reservados com valores para seu aplicativo e conexão.

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

Variáveis

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

Variável	Descrição
azureServiceConnectionId	A ID da conexão de serviço do Azure Resource Manager.
webAppName	O nome do aplicativo Web do Serviço de Aplicativo.
vmImageName	O nome do sistema operacional a ser usado para o agente de compilação.
environmentName	O nome do ambiente para implantar, que é criado automaticamente quando o trabalho de implantação é 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.

Estágios de compilação e implantação

O pipeline consiste em etapas de construção e implantação.

Fase de construção

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

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

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 Python virtual e instala as dependências do aplicativo a partir do 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 criado.

       - 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 forma:

   Parâmetro	Descrição
   rootFolderOrFile	O local do código da aplicação.
   includeRootFolder	Se a pasta raiz deve ser incluída no arquivo .zip . Definido como false. Se definido como true, o conteúdo do arquivo de.zip é colocado em uma pasta chamada s e a tarefa não consegue encontrar o código do aplicativo.
   archiveType	O tipo de arquivo a criar. Definido como zip.
   archiveFile	O local do ficheiro .zip a criar.
   replaceExistingArchive	Indica se um arquivo existente deve ser substituído se o arquivo já existir. Definido 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 de.zip a ser carregado.
   • O artifact parâmetro define o nome do artefato criado como drop.

Fase de implementação

O estágio de implantação é executado se o estágio de compilação for concluído com êxito. As dependsOn palavras-chave e condition 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)

• A deployment palavra-chave indica que o trabalho é um trabalho de implantação direcionado a um ambiente para implantação. O environment é criado automaticamente em seu projeto quando o trabalho é executado.

• O pool parâmetro especifica o pool de agentes de implantação e usa o pool de agentes padrão se um name não for especificado. O agente é executado no sistema operacional definido na vmImageName variável, neste caso ubuntu-latest.

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

  strategy:
    runOnce:
      deploy:
        steps:

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

Nesta etapa, steps execute as seguintes tarefas:

1. UsePythonVersion@0 seleciona a versão do Python a ser usada, a mesma do 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 especificadas no pipeline.
• O appName contém o valor da webAppName variável.
• O package especifica o nome e o local do arquivo de.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 desejado, e selecione Salvar e executar.

   Você pode observar a execução do pipeline selecionando Estágios ou Trabalhos na página Resumo do pipeline. Cada trabalho e estágio exibe uma marca de seleção verde à medida que é concluído com êxito. Se ocorrerem erros, eles aparecem 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.

   

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:

   

Nota

Se uma implantação de aplicativo falhar devido a uma dependência ausente, o arquivo derequirements.txt não foi processado durante a implantação. Esse problema pode ocorrer se você criar o aplicativo Web diretamente no portal em vez de usar o az webapp up comando.

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

Para definir esta ação:

1. Na página do portal do seu aplicativo Web, selecione Configuração no menu de navegação esquerdo.
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. As dependências agora devem ser instaladas durante a implantação.

Iniciar uma execução do pipeline

Esse pipeline é definido para ser executado sempre que uma alteração fizer check-in no repositório de código. Para iniciar 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 do 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 no seu aplicativo Web.
6. No portal do Azure, vá para seu aplicativo Web e selecione Centro de Implantação no menu de navegação esquerdo.
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. 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 bancos de dados externos.

Conforme explicado em 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 startUpCommandAzureWebApp@1 parâmetro na etapa do seu arquivo de pipeline YAML.

Quando você usa o Django, normalmente deseja migrar os modelos de dados usando manage.py migrate depois de implantar o código do aplicativo. Para essa finalidade, você pode adicionar startUpCommand com um script pós-implementação. 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 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 de teste 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 ficheiro 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 Executar testes.

Limpar recursos

Se você tiver terminado com os recursos do Azure criados neste tutorial, exclua-os para evitar incorrer em cobranças adicionais.

• Exclua o projeto de DevOps do Azure 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 as instruções.

Conteúdo relacionado

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