Ler em inglês

Partilhar via


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.
  • Um Servidor de DevOps do Azure.
  • Um agente auto-hospedado. Se você precisar criar um agente auto-hospedado, consulte Agentes auto-hospedados.

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

    Bash
    cd python-sample-vscode-flask-tutorial
    
  2. Compilar e executar a aplicação

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

    Captura de ecrã do botão Azure Cloud Shell na barra de ferramentas do portal do Azure.

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

    Captura de ecrã do Azure Cloud Shell.

  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.

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

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

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

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

    JSON
    {
      "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.

    Azure CLI
    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.
  1. Em um navegador, vá para o Servidor de DevOps do Azure.
  2. Selecione a sua coleção.
  3. Crie um novo projeto selecionando Novo projeto ou Criar projeto se estiver criando o primeiro projeto da coleção.
  4. Insira um nome de projeto.
  5. Selecione a Visibilidade do seu projeto.
  6. Selecione Criar.

Criar um principal de serviço

Um principal de serviço é uma identidade criada para utilização com aplicações, serviços alojados e ferramentas automatizadas para aceder aos recursos do Azure. Esse acesso é restrito às funções atribuídas à entidade de serviço, dando a você controle sobre quais recursos podem ser acessados e em que nível.

Para criar uma entidade de serviço, vá para cloud shell (bash) e execute o seguinte comando. Substitua <service-principal-name> por um nome para a entidade de serviço, <your-subscription-id> pela ID da assinatura e <your-resource-group> pelo grupo de recursos do aplicativo Web.

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

O comando retorna um objeto JSON semelhante ao exemplo a seguir:

JSON
{
  "clientId": "<client GUID>",
  "clientSecret": "<string-value>",
  "subscriptionId": "<subscription GUID>",
  "tenantId": "<tenant GUID>",
  ...
}

Anote os clientIdvalores , clientSecret, subscriptionId, e tenantId . Você precisa desses valores para criar uma conexão de serviço na próxima seção.

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.

    Captura de tela do botão de configurações do projeto no painel 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.

    Captura de ecrã da seleção de ligação de serviço do Azure Resource Manager.

  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.

    Captura de ecrã da caixa de diálogo Nova ligação de serviço.

    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.

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

    Captura de tela do botão de configurações do projeto no painel 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.

    Captura de ecrã da seleção de ligação de serviço do Azure Resource Manager.

  5. Em Nova conexão de serviço do Azure, selecione Entidade de serviço (manual) e selecione Avançar

  6. Na caixa de diálogo seguinte, preencha as informações necessárias.

    Captura de tela da nova caixa de diálogo de conexão de serviço.

    Campo Descrição
    Ambiente Selecione Azure Cloud.
    Nível de âmbito Selecione a Subscrição.
    ID da subscrição O seu ID de subscrição.
    Nome da subscrição Seu nome de assinatura do Azure.
    ID da entidade de serviço O appId valor do objeto JSON retornado pelo az ad sp create-for-rbac comando.
    Chave de Principal de Serviço O password valor do objeto JSON retornado pelo az ad sp create-for-rbac comando.
    ID do inquilino O tenant valor do objeto JSON retornado pelo az ad sp create-for-rbac comando.
  7. Selecione Verificar para verificar a conexão.

  8. Insira um nome de conexão de serviço.

  9. Verifique se a opção Conceder permissões de acesso a todos os pipelines está selecionada.

  10. Selecione Verificar e salvar.

A nova conexão aparece na lista Conexões de serviço e está pronta para os Pipelines do Azure usarem a partir do projeto.

Configurar um agente auto-hospedado

Se você estiver usando seu próprio agente auto-hospedado, precisará configurar o agente para executar o Python. O download de versões do Python não é suportado em agentes auto-hospedados. Você deve pré-instalar a versão do Python. Use o instalador completo para obter uma versão compatível com pip do Python.

Para evitar problemas incompatíveis, você deve corresponder a versão Python com a versão de tempo de execução em seu aplicativo Web dos Serviços de Aplicativo do Azure. A versão de tempo de execução é mostrada na saída JSON do az webapp up comando.

A versão desejada do Python precisa ser adicionada ao cache da ferramenta no agente auto-hospedado para que a tarefa possa usá-la. Normalmente, o cache da ferramenta está localizado sob o diretório _work/_tool do agente; Como alternativa, o caminho pode ser substituído pela variável de ambiente AGENT_TOOLSDIRECTORY. No diretório tools, crie a seguinte estrutura de diretórios com base na sua versão do Python:

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

O número da versão deve seguir o formato 1.2.3. A plataforma deve ser x86 ou x64. Os arquivos da ferramenta devem ser os arquivos de versão do Python descompactados. O {platform}.complete deve ser um arquivo de 0 bytes que se parece x86.complete ou x64.complete e apenas significa que a ferramenta está instalada corretamente no cache.

Por exemplo, se você estiver usando Python 3.11 em uma máquina Windows de 64 bits, a estrutura de diretórios terá esta aparência:

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

Se você já tiver a versão do Python que deseja usar na máquina que hospeda seu agente, poderá copiar os arquivos para o cache da ferramenta. Se você não tiver a versão do Python, você pode baixá-lo do site do Python.

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.

    Captura de tela da seleção de Pipelines no painel do projeto.

  2. Selecione Criar Pipeline.

    Captura de tela do novo botão de pipeline na lista de pipelines.

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

    Captura de tela da seleção GitHub como o local do seu código.

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

    Captura de tela da seleção do repositório.

  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 .

    Instale a extensão Azure Pipelines no GitHub.

    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.

    Captura de tela da extensão Aprovar e Instalar o Azure Pipelines no GitHub.

  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.

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

    Captura de tela da seleção de Pipelines no painel do projeto.

  2. Selecione Criar Pipeline.

    Captura de tela do botão Novo pipeline.

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

    Captura de tela da seleção GitHub como o local do seu código.

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

    Captura de tela da seleção do repositório.

  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 .

    Captura de tela da extensão Azure Pipelines no GitHub.

    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.

    Captura de tela da extensão Aprovar e Instalar o Azure Pipelines no GitHub.

  7. Na caixa de diálogo Configurar seu pipeline, selecione Pipeline inicial.

  8. Substitua o conteúdo do arquivo azure-pipelines.yml pelo código a seguir.

    yml
    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'
    
    
  9. Substitua os seguintes espaços reservados pelos seus próprios valores:

    Marcador de posição Descrição
    <your-service-connection-name> O nome da conexão de serviço que você criou.
    <your-web-app-name> O nome do seu aplicativo Web do Serviço de Aplicativo do Azure.
    <your-pool-name> O nome do pool de agentes que você deseja usar.
    <your-python-version> A versão do Python em execução no seu agente. É uma boa ideia combinar esta versão com a versão Python em execução no seu aplicativo Web. A versão do aplicativo Web é mostrada na saída JSON do az webapp up comando.

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:

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

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

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

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

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

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

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

# Python version: 3.11. Change this to the version that is running on your agent and web app.
pythonVersion: '3.11'
Variável Descrição
azureServiceConnectionId O nome da conexão de serviço do Azure Resource Manager.
webAppName o nome da aplicação Web.
environmentName O nome do ambiente usado no estágio de implantação.
projectRoot A pasta que contém o código do aplicativo. O valor é uma variável automática do sistema.
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.

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

O estágio de compilação contém um único trabalho que é executado em um agente no pool identificado pelo parâmetro name. Você pode especificar os recursos do agente com a demands palavra-chave. Por exemplo, demands: python especifica que o agente deve ter o Python instalado. Para especificar um agente auto-hospedado pelo nome, você pode usar a demands: Agent.Name -equals <agent-name> palavra-chave.

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

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.

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

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

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

yml
  dependsOn: Build
  condition: succeeded()

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

yml
  - 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.
yml
  - deployment: DeploymentJob
    pool:
      name: <your-pool-name>
    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 a ser usado para implantação. Esse pool deve conter um agente com a capacidade de executar a versão python especificada no pipeline.
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.

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

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

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

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.

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

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

    yml
      - task: AzureWebApp@1
         displayName: 'Deploy Azure Web App : $(webAppName)'
         inputs:
           azureSubscription: $(azureServiceConnectionId)
           appName: $(webAppName)
           package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
           startUpCommand: 'startup.txt'
    
    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.
    startUpCommand O comando a ser executado após a implantação do aplicativo. O aplicativo de exemplo usa startup.txto .

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.

    Captura de tela da seção de estágios de resumo da execução do pipeline.

    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.

    Captura de tela das etapas do estágio do pipeline.

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

    Captura de tela do comentário do pipeline de edição de um relatório de compilação.

  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:

    Captura de ecrã da vista da aplicação de exemplo em execução no Serviço de Aplicações.

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.

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

yml
# 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