Personalizar o Python para o Azure Pipelines

  • Artigo

Você pode usar o Azure Pipelines para criar seus aplicativos Python sem precisar configurar uma infraestrutura própria. As ferramentas que você normalmente usa para criar, testar e executar os aplicativos Python, como pip, são pré-instaladas em agentes hospedados pela Microsoft no Azure Pipelines.

Para criar seu primeiro pipeline com o Python, confira o Início rápido do Python.

Usar uma versão específica do Python

Para usar uma versão específica do Python em seu pipeline, adicione a tarefa Usar Versão do Python no azure-pipelines.yml. Este snippet define o pipeline para usar o Python 3.11:

steps:
- task: UsePythonVersion@0
  inputs:
    versionSpec: '3.11'

Usar várias versões do Python

Para executar um pipeline com várias versões do Python, por exemplo, para testar um pacote nessas versões, defina um job com uma matrix das versões do Python. Em seguida, defina a tarefa UsePythonVersion para fazer referência à variável matrix.

jobs:
- job: 'Test'
  pool:
    vmImage: 'ubuntu-latest' # other options: 'macOS-latest', 'windows-latest'
  strategy:
    matrix:
      Python38:
        python.version: '3.8'
      Python39:
        python.version: '3.9'
      Python310:
        python.version: '3.10'

  steps:
  - task: UsePythonVersion@0
    inputs:
      versionSpec: '$(python.version)'

Você pode adicionar tarefas a serem executadas usando cada versão do Python na matriz.

Executar scripts do Python

Para executar os scripts do Python em seu repositório, use o elemento script e especifique o nome de arquivo. Por exemplo:

- script: python src/example.py

Você também pode executar scripts do Python embutidos com a tarefa Script do Python:

- task: PythonScript@0
  inputs:
    scriptSource: 'inline'
    script: |
      print('Hello world 1')
      print('Hello world 2')

Para parametrizar a execução do script, use a tarefa PythonScript com valores arguments para passar argumentos para o processo de execução. Você pode usar sys.argv ou a biblioteca mais sofisticada argparse para analisar os argumentos.

- task: PythonScript@0
  inputs:
    scriptSource: inline
    script: |
      import sys
      print ('Executing script file is:', str(sys.argv[0]))
      print ('The arguments are:', str(sys.argv))
      import argparse
      parser = argparse.ArgumentParser()
      parser.add_argument("--world", help="Provide the name of the world to greet.")
      args = parser.parse_args()
      print ('Hello ', args.world)
    arguments: --world Venus

Instalar dependências

Você pode usar scripts para instalar os pacotes PyPI específicos com pip. Por exemplo, esse YAML instala ou atualiza pip e os pacotes de setuptools e wheel.

- script: python -m pip install --upgrade pip setuptools wheel
  displayName: 'Install tools'

Requisitos de instalação

Depois que você atualizar pip e amigos, uma próxima etapa típica será instalar as dependências do requirements.txt:

- script: pip install -r requirements.txt
  displayName: 'Install requirements'

Executar testes

Use scripts para instalar e executar vários testes em seu pipeline.

Executar testes de lint com flake8

Para instalar ou atualizar flake8 e usá-lo para executar testes de lint, use este YAML:

- script: |
    python -m pip install flake8
    flake8 .
  displayName: 'Run lint tests'

Testar com pytest e coletar métricas de cobertura com pytest-cov

Use esse YAML para instalar pytest e pytest-cov, executar testes, obter saídas de resultados de teste no formato JUnit e saídas de resultados de cobertura de código no formato Cobertura XML:

- script: |
    pip install pytest pytest-azurepipelines
    pip install pytest-cov
    pytest --doctest-modules --junitxml=junit/test-results.xml --cov=. --cov-report=xml
  displayName: 'pytest'

Executar testes com o Tox

O Azure Pipelines pode executar trabalhos paralelos de testes do Tox para dividir o trabalho. No computador de desenvolvimento, você precisa executar os ambientes de testes em série. Este exemplo usa tox -e py para executar qualquer versão do Python ativa para o trabalho atual.

- job:

  pool:
    vmImage: 'ubuntu-latest'
  strategy:
    matrix:
      Python38:
        python.version: '3.8'
      Python39:
        python.version: '3.9'
      Python310:
        python.version: '3.10'

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

  - script: pip install tox
    displayName: 'Install Tox'

  - script: tox -e py
    displayName: 'Run Tox'

Publicar resultados de teste

Adicione a tarefa Publicar Resultados de Teste para publicar os resultados do teste JUnit ou xUnit no servidor:

- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testResultsFiles: '**/test-*.xml'
    testRunTitle: 'Publish test results for Python $(python.version)'

Publicar resultados de cobertura de código

Adicione a tarefa Publicar Resultados de Cobertura de Código para publicar os resultados de cobertura de código no servidor. Você pode ver as métricas de cobertura no resumo do build e baixar os relatórios HTML para análise posterior.

- task: PublishCodeCoverageResults@1
  inputs:
    codeCoverageTool: Cobertura
    summaryFileLocation: '$(System.DefaultWorkingDirectory)/**/coverage.xml'

Empacotar e entregar o código

Para autenticar com twine, use a tarefa Autenticação do Twine para armazenar credenciais de autenticação na variável de ambiente PYPIRC_PATH.

- task: TwineAuthenticate@0
  inputs:
    artifactFeed: '<Azure Artifacts feed name>'
    pythonUploadServiceConnection: '<twine service connection from external organization>'

Em seguida, adicione um script personalizado que usa twine para publicar seus pacotes.

- script: |
   twine upload -r "<feed or service connection name>" --config-file $(PYPIRC_PATH) <package path/files>

Você também pode usar o Azure Pipelines para criar uma imagem para seu aplicativo Python e efetuar push dela em um registro de contêiner.