Scripting: automação de tarefas com Python e criação de Pipelines no Jenkins

Construindo scripts em Python - Apresentação

Olá, meu nome é Lucas Ribeiro Mata, sou instrutor na Alura.

Audiodescrição: Lucas se declara como uma pessoa branca. Tem barba e cabelo preto e usa óculos de armação preta e redonda. Esta vestindo uma camiza cinza e está no estúdio da Alura. Está sentado em uma cadeira games de encosto preto e tem um microfone à sua frente. O fundo é uma parede iluminada por luzes rosa e roxa e, no lado direito, há uma estante com vários itens decorativos, como figuras de ação e placas decorativas.

Boas-vinda a este curso! Nele, daremos passo importante no aprendizado de automatização de processos, utilizando scripts em Python. Recomendamos que você tenha concluído o curso anterior desta formação, assim poderá aproveitar melhor o conteúdo que vamos explorar.

O que aprenderemos

Construiremos scripts de automação de tarefas, utilizando Python como linguagem. Além disso, criaremos pipelines de desenvolvimento e vamos automatizar a realização de testes e análises em códigos.

Também vamos gerar uma documentação e artefatos para fazer o deploy de forma automatizada. Por fim, analisaremos como criar scripts para fazer análise de dados gerados por sistemas de uma forma rápida.

O que aprenderemos:

• Construção scripts de automatização de tarefas em Python;
• Criação pipeline de desenvolvimento;
• Automatização testes e análise de códigos;
• Criação de deploy automatizado;
• Criação de scripts para análise de dados.

Aprenderemos tudo isso de forma contextualizada e prática. Vamos nos deparar com algumas situações reais de uso de scripts em Python. Nessa jornada, adotaremos como ferramenta o Jenkins, um servidor de código aberto que podemos utilizar para automatização do pipeline de desenvolvimento, adotando práticas de CI/CD bem comuns no cotidiano de DevOps.

Vamos iniciar a nossa jornada de estudos!

Construindo scripts em Python - Criando ambientes virtuais

A criação de ambientes virtuais é uma prática bastante comum quando lidamos com diferentes projetos. Muitas vezes, podemos estar construindo uma aplicação em um dado momento, mas queremos conferir outras aplicações similares para fazer um benchmark (comparação) com o código e a abordagem de desenvolvimento que estamos utilizando.

Entendendo o processo de comparação de código

Para analisar essas diferentes aplicações, cada uma com seu conjunto de dependências e bibliotecas, para não ter nenhum tipo de conflito no nosso ambiente, criamos um ambiente virtual. Dentro desse ambiente virtual, instalamos todas as dependências necessárias para a execução de uma dada aplicação.

Essa é uma prática interessante porque isola as dependências, que ficam instaladas dentro desses ambientes virtuais. Assim, elas não terão nenhum tipo de conflito com outras dependências que eventualmente possam estar instaladas no ambiente de trabalho que estamos usando.

Criando um ambiente virtual para Python

Quando trabalhamos com projetos Python, temos a Virtual Env (vitualenv), uma ferramenta que nos ajuda a criar ambientes virtuais, e agora instalaremos essa ferramenta no nosso PC. Para isso, em uma interface de linha de comando, podemos usar o pip, gerenciador de pacotes do Python, com o comando install virtualenv para fazermos o download de todos os pacotes.

pip install virtualenv

Após essa instalação partir desse momento, temos essa ferramenta na nossa máquina e já conseguimos criar um ambiente virtual para projetos Python, e é o que faremos. Ainda por linha de comando, criaremos um ambiente chamado de teste, executando o comando:

virtualenv test

As informações que recebemos na nossa interface indicam que nosso ambiente foi criado.

Acessando o ambiente virtual

Para acessarmos esse ambiente, usamos o comando source nome-do-ambiente/bin/activate, portanto, nosso comando é:

source teste/bin/activate

Notem que já não estamos mais na home da nossa interface, no meu caso, do Ubuntu. Agora estamos no ambiente virtual "teste", que acabamos de criar.

A importância da automatização de processos

Uma das coisas que trabalharemos ao longo desse curso é a automatização de tarefas e processos, principalmente aquelas relacionadas à construção de projetos. Estamos começando com a criação de um ambiente virtual porque podemos usar um script em Python para tornar mais simples esse processo de criação de ambientes virtuais.

Ao invés de termos que ficar digitando comando a comando para criarmos esses ambientes virtuais, o que pode ser ainda mais complexo. Por exemplo, podemos precisar instalar as dependências para um projeto que será executado dentro desse ambiente virtual.

Por exemplo, ao acessarmos o projeto "dash", no GitHub da Alura, encontramos um projeto baseado no framework Flask. Esse projeto é uma modificação do framework Flask, chamado de "Dash".

O Dash possibilita a visualização e a interação com dashboards, permitindo que consigamos visualizar modelos estatísticos. Esse projeto foi construído especificamente visualizar alguns modelos de machine learning (aprendizagem de máquina). Como sabemos, machine learning envolve muita estatística, portanto, conseguimos visualizar estatística e graficamente os dados.

Analisando a pasta desse projeto, encontramos o arquivo requirements.txt. Clicando nesse arquivo, encontramos todas as dependências necessárias para a boa execução do Dash. Agora que já temos um ambiente virtual criado, se tivéssemos que prepará-lo para a execução desse projeto, teríamos que ir instalando cada uma das dependências necessárias:

plotly==5.19.0
ucimlrepo==0.0.3
pandas==2.2.0
dash==2.15.0
scikit-learn==1.4.1.post1
xgboost==2.0.3
dash-bootstrap-components==1.0.0

Para tornar isso mais prático, poderíamos construir uma ferramenta que cria esse ambiente onde informamos a localização do diretório do projeto, e que as dependências necessárias para ele funcionar, e que precisam ser instaladas, estão em um arquivo .txt. Podemos fazer isso usando um script do Pyton.

Automatizando por scripts Python

Para começarmos, precisamos pensar nas etapas que precisamos cumprir para que esse processo ser concluído com êxito, o chamado pensamento algorítmico. A partir desse pensamento mais analítico, constatamos quais etapas que devemos realizar e partimos para a construção do código propriamente dito.

Retornando para nossa interface de linha de comando, para sairmos do ambiente virtual, usamos o comando deactivate. Assim voltamos para a o início da interface.

Criando um script

Podemos começar a construir esse script, nesse caso, usaremos o editor de texto padrão do Ubuntu: o Nano. Ao executarmos o comando nano no Ubunu, acessamos o editor de texto.

O primeiro passo ao construirmos um script em Python é identificar quais as bibliotecas que utilizaremos nessa construção. Nesse curso, usaremos três bibliotecas, que vão nos permitir a interação direta com o sistema operacional, incluindo a realização de alguns comandos no sistema.

Bibliotecas que utilizaremos:

• OS
• Subprocess
• Sys

Primeiramente escreveremos o comando import os, que fornecerá as funções para a interação com o sistema operacional. Depois o import subprocess, que nos permite realizar alguns subprocessos no sistema. Por fim, o import sys.

Completaremos esse script no próximo vídeo.

Construindo scripts em Python - Scripts de automação em Python

Continuaremos escrevendo um script para automatizar a criação de ambiente virtual e instalar todas as dependências necessárias para a execução de um projeto. Já importamos as bibliotecas e agora começamos a implementar as funções.

Preparando a automação

Na função principal (def main()), nosso primeiro passo será solicitar que a pessoa usuária informe algum tipo de argumento com o caminho do diretório do projeto para o qual ela deseja criar esse ambiente virtual. Espera-se que a pessoa, ao executar este script usando Python, porque é a linguagem do nosso script, passe o python3 nome_do_script e um path (caminho) para o diretório do projeto.

Portanto, faremos a coleta da primeira variável, que definiremos como diretorio_projeto. Esta variável será igual ao argumento informado pela pessoa usuária, e extrairemos essa informação com a função sys.argv[] da biblioteca sys. Entre os colchetes, passaremos o número 1, ou seja, passaremos o primeiro argumento informado pela pessoa usuária.

import os
import subprocess
import sys

def main():
    diretorio_projeto = sys.argv[1]

Após essa variável, verificaremos se esse diretório tem arquivo requirements.txt. Armazenaremos esse arquivo na variável requirements_file, seguindo a mesma nomenclatura que estamos adotando.

Mais uma vez, usaremos uma função das bibliotecas que importamos: os.path.join(). Nos parênteses, passaremos dois parâmetros: o diretorio_projeto, onde ele buscará o arquivo, e o arquivo 'requirements.txt', que deve estar no diretório do projeto.

import os
import subprocess
import sys

def main():
    diretorio_projeto = sys.argv[1]
    requirements_file = os.path.join(diretorio_projeto, 'requirements_txt')

Definimos essas duas primeiras variáveis que usaremos neste script. Agora precisaremos implementar duas funções: uma para criar um ambiente virtual e outra para instalar as dependências dentro desse ambiente.

Dentro dessas funções, faremos algumas verificações, por exemplo, se o caminho do diretório é válido e se o requirements.txt existe. Se não existir, informaremos à pessoa usuária.

Criando as funções de automação

Começaremos com a função para criar o ambiente virtual, e chamaremos de criar_ambiente(). Como parâmetro dessa função, passaremos o diretorio_projeto, a variável que acabamos de criar. Abaixo dela, criaremos a função instalar_dependencias(), passando como parâmetro o diretorio_projeto e a variável requirements_file.

# código omitido

def main():
    diretorio_projeto = sys.argv[1]
    requirements_file = os.path.join(diretorio_projeto, 'requirements_txt')
    criar_ambiente(diretorio_projeto)
    instalar_dependencias(diretorio_projeto, requirements_file)

Atenção: Como a interface do Nano não é muito amigável, precisamos tomar cuidado com a digitação do código. Qualquer erro de digitação também será um erro na execução do script.

Automatizando a criação de ambiente virtual

Após criarmos as funções, podemos começar a implementá-las. Começando pela função criar_ambiente, cima da def main(), escreveremos def criar_ambiente(diretorio):.

Dentro dessa função, o primeiro passo é verificar se o caminho do diretório é válido, codando if not os.path.exists(diretorio_projeto). Ou seja, se esse caminho for inválido, usaremos a função os.path.exists(), que vem da biblioteca os, passando o diretório como parâmetro. Se for confirmado que o diretório não existe, usaremos um print() para reportar isso para pessoa usuária. Por fim, finalizamos o if com um return.

def criar_ambiente(diretorio_projeto):
    if not os.path.exists(diretorio_projeto):
        print("O diretorio informado não existes")
        return

A próxima tarefa dentro da criar_ambiente é criar um caminho para o ambiente virtual, então criaremos uma variável chamada venv_path que recebe a função os.path.join(). Como argumentos, passaremos primeiro o diretorio_projeto e depois o termo 'venv'. Este será o nome do ambiente virtual que criaremos.

venv_path = os.path.join(diretorio_projeto, 'venv')

Em seguida, verificaremos se já existe um ambiente virtual com esse nome, usando mais um if:

if os.path.exists(venv_path):
    print("O ambiente virtual já existe")
    return

Informamos o nome da variável que acabamos de criar para verificar a existência do ambiente virtual. Caso exista, fazemos um print("O ambiente virtual já existe") e, por fim, o return.

Dica: O espaçamento maior dentro da função melhora a visibilidade do código.

A próxima tarefa é criar o ambiente virtual de fato. Para isso, codamos o try e, dentro dele, usamos uma função da biblioteca subprocess, a função run(). Essa função roda um comando dentro da nossa máquina, e escrevemos como subprocess.run().

Nos parênteses, escreveremos primeiro colchetes ([]) contendo a sequência de comandos para a criação de um ambiente virtual. O primeiro é o 'virtualenv'. Normalmente chamamos de "venv", mas o comando é virtualenv. Ainda nos parênteses, mas fora dos colchetes, terminamos a execução com check=True.

subprocess.run(['virtualenv', venv_path], check=True)

Abaixo da linha da função, indicaremos para a pessoa usuária se o ambiente virtual foi criado, com um print("Ambiente criado com êxito"). Por fim, caso ocorra algum tipo de erro na criação desse ambiente, usaremos o except subprocess.CalledProcessError as e:.

Com essa função, indicamos para a pessoa usuária que ocorreu um erro e mostraremos quais erros ocorreram nesse processo. Sendo assim, também usaremos um print() passando o f"Erro ao criar o ambiente: {e}". Dessa forma, além de indicar que houve um erro, indicamos qual o erro aconteceu, passando {e}.

def criar_ambiente(diretorio_projeto):
    if not os.path.exists(diretorio_projeto):
        print("O diretorio informado não existes")
        return

    venv_path = os.path.join(diretorio_projeto, 'venv')
    
    if os.path.exists(venv_path):
        print("O ambiente virtual já existe")
        return
    
    try:
    subprocess.run(['virtualenv', venv_path], check=True)
        print("Ambiente criado com êxito")
    except subprocess.CalledProcessError as e:
        print(f"Erro ao criar o ambiente: {e}")

Já temos a função de criação do ambiente virtual implementada no script. A seguir, continuaremos a construção desse script com a implementação da função de instalação de dependência. Com isso, finalizaremos e revisaremos o que elaboramos.

Sobre o curso Scripting: automação de tarefas com Python e criação de Pipelines no Jenkins

O curso Scripting: automação de tarefas com Python e criação de Pipelines no Jenkins possui 141 minutos de vídeos, em um total de 45 atividades. Gostou? Conheça nossos outros cursos de Automação de processos em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Construindo scripts em Python
• Automatização de testes
• Pipelines de desenvolvimento
• Avançando na automação do pipeline
• Criando containers e analisando dados