Instalando AllEx

Objetivo

Descrever os procedimentos para instalação do Allex em servidores CentOS 8 e RHEL 8 e demonstrar como configurar o ambiente.

Suporte

Essa configuração é suportada pela OpServices para os clientes OpMon Premium e pelos parceiros para os clientes OpMon PRO.

Público-Alvo

Administradores do OpMon.

Pré-Requisitos

• 1vCPU
• 2GB de RAM
• 100GB de espaço para cada robot em execução simultânea.

• 4vCPU
• 8GB de RAM
• 400GB de disco para gravação dos vídeos

• Certificado SSL para o OpMon e para o AllEx
• Acesso SSH e WEB ao OpMon e ao Allex
• Acesso a internet a partir do Allex e do OpMon para instalação do software necessário

Premissa importante

Os robôs são executados a partir do Jenkins.

1. A biblioteca instância a leitura do arquivo global.yaml (/usr/local/allex/etc/global.yam)
   1. Processa as informações necessárias
2. XVFB é iniciado em uma porta aleatório alta (não TCP)
   1. O XVFB possibilita a execução simultâneas de robôs para a gravação
3. Chrome e ChromeDriver são iniciados
   1. Cada instância de XVFB usa um chrome e um chromeDriver
4. FFMPEG conecta na porta do XVFB para iniciar a gravação do vídeo durante a execução do robô
5. Ao término da execução, sendo ela ok ou não, os dados são enviados para o OpMon a partir de uma API HTTPS
6. O vídeo é armazenado na base de dados

Instalação

A instalação do Allex é feita a partir de um pacote RPM para centOs 8 e repositórios adicionais epel e rpmfusion.

Para adicionar os repositórios no centOs 8 e instalar os pacotes necessário, segue abaixo (necessário root):

Antes de qualquer coisa, verifique se há firewall e selinux ativos para desabilitar.

# systemctl stop firewalld 
# systemctl disable firewalld

 

# wget -O rpmfusion-free-release-8.noarch.rpm https://download1.rpmfusion.org/free/el/rpmfusion-free-release-8.noarch.rpm
# dnf install rpmfusion-free-release-8.noarch.rpm
# wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat/jenkins.repo
# rpm --import https://pkg.jenkins.io/redhat/jenkins.io-2023.key

Remova o Chromium, primeiro veja as versões instaladas e após disso, remova os pacotes, sem remover as dependências, segue abaixo:

# rpm -qa | grep chromium
# chromium-common-85.0.4183.83-1.el8.x86_64
# chromium-85.0.4183.83-1.el8.x86_64
# rpm -e --nodeps chromium-85.0.4183.83-1.el8.x86_64 chromium-common-85.0.4183.83-1.el8.x86_64

Configurar o repositório do Chrome:

Valide a última versão do pacote do Allex e complete a url do curl mais abaixo, link dos pacotes abaixo:

http://localrepo.opservices.com.br/rpms/allex/

# curl http://localrepo.opservices.com.br/rpms/allex/allex-<VERSION>.x86_64.rpm -o allex.x86_64.rpm
# enable repo PowerTools
# dnf config-manager --set-enabled PowerTools
# dnf install epel-release -y
# dnf clean all ; dnf install allex.x86_64.rpm -y

A instalação dos arquivos ficam no diretório: /usr/local/allex

Configurações gerais: /usr/local/allex/etc/global.yaml

       settings:
             video:
               resolution: 1280x720
             robot:
               timeout: 600
               step_timeout: 30
             opmon:
               address: https://<address>
               username: ******************** 
               password: ********************
             allex:
               address: https://<adresss>/videos
             db:
               address: <ip address>
               username: ***********
               password: ***********
               dbname: allex

Criação de robôs

Os robôs criados devem ficar no diretório: /usr/local/allex/robots

Para facilitar a criação de robôs foram construídas algumas bibliotecas, mas mantendo o suporte completo do Selenium, ou seja, todo código necessário haverá exemplo na internet e as funções necessárias.

Alguns links para apoio:

• https://selenium-python.readthedocs.io/navigating.html
• https://selenium-python.readthedocs.io/locating-elements.html
• https://selenium-python.readthedocs.io/waits.html
• https://www.geeksforgeeks.org/click-element-method-selenium-python/

Entendendo funções em Python (lambda e def):

• https://medium.com/@otaviobn/entendendo-as-fun%C3%A7%C3%B5es-lambda-no-python-cbe3c5abb179
• http://pythonclub.com.br/progrmacao-funcional-com-python-1.html

Abaixo há um exemplo de um robô criado:

 from selenium.webdriver.common.by import By

     from selenium.webdriver.common.action_chains import ActionChains
     from selenium.webdriver.support.wait import WebDriverWait
     from selenium.webdriver.support import expected_conditions as ExpectedConditions
     import sys
     # As bibliotecas acima são necessárias para execução do Selenium e como já mencionado, seguindo o padrão que já existe em documentações

     sys.path.append('/usr/local/allex/lib')
     from Allex import Allex
     # A biblioteca acima foi a desenvolvida para facilitar a criação do robô

     allex = Allex() 
     # Cria o objeto Allex - encapsula o chromedriver na propriedade “allex.browser”, conforme usado na função “addStep”

     allex.start() 
     # Inicia os processos necessário para a execução do robô, como XVFB, Chrome, ChromeDriver, FFMPEG e etc.

     wait = WebDriverWait(allex.browser, allex.stepTimeout) 
     # Este “WebDriverWait” é padrão do Selenium, ele serve para esperar algum elemento da página aparecer e neste exemplo ele segue o tempo padrão de timeout definido no global.yaml de 30 segundos

     allex.addStep(
       "site",
       lambda: (
         allex.browser.get("https://www.muenchen.de"),
         wait.until(ExpectedConditions.visibility_of_element_located((By.CSS_SELECTOR, ".logo > img")))
       )
     )
     # A função acima gera o passo, ou seja, pode haver diversas chamadas desta função que o robô seguirá a ordem.
        # 1 - Nesta função a primeira opção é o nome do passo, neste caso “site”
        # 2 - A segunda opção ele recebe uma função, no Python podendo ser uma “lambda” ou uma função já declarada com “def”
        # 3 - 3Pela simplicidade do robô, dentro do lambda são utilizada apenas duas função, a allex.browser.get, onde acessa a página digitada e a função wait.until, declarada mais acima, ela espera o elemento aparecer

     allex.send()
     # Esta última função faz o processamento para encerrar a execução do robô, da gravação e envio dos dados.

Criação Ciclo no Jenkins

A senha do Jenkins estará após a instalação do RPM do Allex, conforme abaixo:

cat /var/lib/jenkins/secrets/initialAdminPassword
*******************************

Altere a senha que foi gerada randomicamente.

Acesse o Jenkins pelo IP do servidor “http://address:8080” com o usuário admin e senha já configurada.

Para incluir um robô no ciclo, click no menu à esquerda chamado “New Item” marcado em amarelo

Na próxima tela, basta adicionar o nome do job que será o nome do serviço no OpMon, selecionar o item “Pipeline” e clicar no “OK”, conforme as marcações em amarelo abaixo:

Após clicar em “OK”, nas quatro abas, clique na aba “Pipeline”, conforme marcado em amarelo.

Valide o combobox “Definition”, a opção correta deve ser “Pipeline script”, e para o campo de texto denominado “Script”, deve conter a chamada do robô e opções padrões que o mesmo utiliza, sendo elas, -H de host_name e a opção -S de service_description ambos para qual host e serviço será enviada a checagem passiva no OpMon configurado. Conforme conforme as marcações em amarelo e código de exemplo abaixo:

Código do Pipeline script:

     pipeline {
       agent any
       stages {
         stage('RunRobot') {
           steps {
             script {
                 $JOBNAME = env.JOB_NAME
                 withCredentials([usernamePassword(credentialsId: 'OpMonLogin', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
                     sh 'export DISPLAY=localhost:10.0; /usr/bin/python3 /usr/local/allex/robots/opmonreport.py -H Robots_Debug -S "$JOB_BASE_NAME" -u "$USERNAME" -p "$PASSWORD"'
                 }
             }
           }
         }
       }
     }

As opções de -u e -p, são para robôs que necessitam de um login, usuário e senha. Por questões de segurança, a credencial do mesmo, deve também ser criada no Jenkins e selecionada para utilizar no robô através das macros, como na imagem e código de exemplo acima.

Para criar a credencial no Jenkins, clicar no menu a esquerda “Manage Jenkins”.

Clicar na opção “Manage Credentials”.

Na parte denominada “Stores scoped to Jenkins“, clicar na seta para abrir a opção “Add credentials”.

Verificar os campos “Kind” com a opção “Username with password” e “Scope” com a opção “Global (jenkins, nodes, items, all child item, etc)”, preencha as demais opções e conclua clicando no “OK”.

Para utilizar essa credencial no robô, conforme o exemplo do código do Pipeline script acima, o trecho abaixo explica como passar o “ID” da credencial cadastrada:

Opções customizáveis também podem ser inseridas no comando, como exemplo, estou fazendo um robô que insere uma matrícula, porém há mais robôs iguais usando matrículas diferentes, basta então no código do robô incluir uma função nova, segue exemplo:

     allex = Allex() 
     allex.options.add_argument("-m", dest="matricula")

     allex.start() 

     allex.addStep(
         "acessa matricula",
         lambda: (
             allex.browser.find_element(By.CSS_SELECTOR, '.x-input-el[placeholder="User"]').send_keys(allex.options.matricula),
             allex.browser.find_element(By.CSS_SELECTOR, '.x-button-el[type="submit"]').click(),
wait.until(ExpectedConditions.visibility_of_element_located((By.ID, "mainMenu")))
         )
      )

Após ter adicionada a nova opção de argumento em código, a opção -m, pode ser usada na linha de comando do “Pipeline script”, semelhante ao -H, -S, -u e -p.

Job de retenção no Jenkins

Agora que sabemos configurar jobs no Jenkins e já temos o primeiro robô configurado. Vamos adicionar o Job que mantém uma retenção dos dados do robô, segue abaixo:

Novo item:

Nome deve ser __Clean videos from DB

Configurar o período de execução:

Configurar o comando a ser executado: