Lab 1.10: Utilizando linters e ferramenta de segurança

Analisando código com ruff

Agora que já temos um pacote Python pronto para ser distribuído, é fundamental adotar práticas de qualidade de código que garantam a legibilidade, consistência e segurança do seu código. Uma ferramenta poderosa para ajudar nesse processo é o Ruff.

Ruff

Ruff é um linter rápido e eficiente para Python. Ele foi projetado para ser altamente configurável e rápido, realizando verificações de estilo e erros de código. Ele é mais rápido que outros linters populares (como o pylint e flake8) devido ao seu design otimizado e ao uso de técnicas de compilação.

Benefícios do Ruff:

Desempenho: O Ruff é significativamente mais rápido do que linters tradicionais como o - pylint e flake8.
Facilidade de Uso: Requer pouca configuração e é fácil de integrar em seu fluxo de trabalho.
Alta Configuração: Você pode configurar quais regras deseja aplicar, ou até mesmo desativar certas verificações.
Compatibilidade: O Ruff oferece compatibilidade com diversas regras de linters populares, como flake8, black, isort, etc.
Análise de Segurança: Além de verificar o estilo do código, ele também verifica problemas de segurança, como importações não utilizadas e práticas arriscadas.

Como Integrar o Ruff no Seu Pacote Python localmente?

1 - Instalando o Ruff o primeiro passo é instalar o Ruff no seu ambiente de desenvolvimento. Você pode instalá-lo com o pip:

pip install ruff

2 - Rodando o Ruff no Código: Para rodar o Ruff em um diretório (onde seu pacote Python está localizado, por exemplo), rode o seguinte comando:

ruff check .

Isso irá verificar todo o código no diretório atual e subdiretórios. O Ruff então irá mostrar qualquer problema encontrado, como problemas de formatação ou uso incorreto de importações. Como podemos ver abaixo:

O Ruff identificou 3 erros, onde:

Na linha 14 do arquivo csv_functions erro de indentação, em decorrência do avanço da doc string.
Na linha 16 do arquivo csv_functions erro de indentação, em decorrência do avanço da doc string.
Na linha 6 do arquivo email_functions erro gerado por estar usando uma classe sem o devido import.

Após corrigir esses erros, ao rodar novamente ruff check . todas as verificações finalizaram sem problemas.

Buscando vulnerabilidades de dependências com Snyk

O Snyk é uma ferramenta de segurança para desenvolvedores, focada principalmente em detectar e corrigir vulnerabilidades de segurança em dependências de código, infraestrutura e pipelines de CI/CD.

O Snyk ajuda a proteger as aplicações contra problemas de segurança que podem ser introduzidos por pacotes e bibliotecas externas, além de oferecer monitoramento contínuo da segurança.

Como o Snyk atua na segurança de dependências

Análise de Dependências

O Snyk realiza a análise automática das dependências de um projeto. Ele escaneia tanto as dependências diretas (pacotes explicitamente incluídos no projeto) quanto as dependências transitivas (pacotes que essas dependências diretas exigem).
Ao escanear o projeto, o Snyk identifica as bibliotecas e versões usadas, e compara essas versões com uma base de dados de vulnerabilidades conhecidas, que contém informações sobre falhas de segurança já documentadas em várias bibliotecas populares.

Identificação de Vulnerabilidades:

Após realizar a análise, o Snyk identifica vulnerabilidades conhecidas nas dependências do projeto. Ele pode detectar problemas como:
- CVE (Common Vulnerabilities and Exposures): O Snyk utiliza bancos de dados de CVEs para identificar falhas já publicadas na segurança de software.
- Vulnerabilidades específicas de pacotes: O Snyk não se limita apenas a problemas CVE, ele também verifica por falhas específicas em pacotes e versões populares.
O Snyk também considera vulnerabilidades em tempo de execução e problemas relacionados a permissões de pacotes, garantindo que não haja riscos durante a execução do software.

Recomendações de Correção:

Para cada vulnerabilidade detectada, o Snyk fornece recomendações claras de como corrigi-las. Isso pode incluir:
- Atualizar para uma versão segura da dependência.
- Substituir uma dependência vulnerável por uma alternativa mais segura.
- Aplicar patches (em alguns casos, se disponível).

Caso queira aprender como rodar o Snyk via linha de comando, acesse o nosso conteúdo extra

Integrando o Ruff no CI/CD

Agora, vamos configurar o Ruff para ser executado automaticamente em um pipeline de CI/CD. Vou exemplificar o processo usando o GitHub Actions, mas o conceito é semelhante em outras ferramentas de CI/CD.

1 - Criar o arquivo de configuração do GitHub Actions

Na raiz do seu repositório, crie o arquivo .github/workflows/ruff.yml com o seguinte conteúdo:

name: Lint with Ruff

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  lint:
    runs-on: ubuntu-latest

    steps:
    - name: Check out repository
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v3
      with:
        python-version: '3.x'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install ruff  # Instala o Ruff

    - name: Run Ruff Linting
      run: ruff .

Onde:

on: Define os eventos que acionam o workflow. Neste caso, ele será executado em:
- push: Aciona o pipeline quando houver um push na branch main.
- pull_request: Aciona o pipeline quando houver um pull request para a branch main.
jobs: Define os jobs do CI. O job lint será executado em um runner Ubuntu:
- steps: Cada etapa do job:
  - Check out repository: Faz o checkout do código do repositório.
  - Set up Python: Configura o ambiente Python com a versão 3.x.
  - Install dependencies: Atualiza o pip e instala as dependências do projeto (definidas no requirements.txt), além de instalar o Ruff.
  - Run Ruff Linting: Executa o Ruff para verificar todos os arquivos Python do projeto.

2 - Adicionar o arquivo de configuração ao repositório

Use os comandos do Git para adicionar esse arquivo ao repositório remoto:

git add .github/workflows/ruff.yml

git commit -m "Adiciona pipeline de linting com Ruff"

git push origin main

3 - Verificar a execução do pipeline

Após configurar o GitHub Actions, sempre que houver um push ou pull_request para a branch main, o GitHub acionará o pipeline e executará a análise de linting do Ruff, ela pode ser visualizada na aba Actions do repositório:

Se houver problemas no código, eles serão exibidos nos logs do pipeline como abaixo:

Mas, caso contrário retornará sucesso em todas as etapas:

Configurando o Ruff para rodar antes de um Commit (opcional)

Se você quiser garantir que o código seja verificado antes de ser comitado, pode usar uma ferramenta como pre-commit para integrar o Ruff diretamente ao processo de commit.