Introdução

No artigo anterior foi apresentado como criar uma stack básica de desenvolvimento com o Jenkins. Agora vamos avaliar alguns desafios que surgiram e como melhorá-los.

Exlusão de containers

Usando o comando docker-compose down removemos todos so recursos criados pelo comando docker-compose up e o arquivo docker-compose.yml. Porém, os volumes criados não são automaticamente removidos. Depois de executar muitas vezes os comandos, teremos o seguinte cenário:

Você pode remover os volumes individualmente com o comando docker volume rm [id container] ou removendo todos os volumes não utilizados com o comando docker volume prune.

Jenkins - Configuration as Code

A partir de agora vamos tratar todas as configurações como código. Para isto, precisamos de uma estrutura de diretórios organizadas da seguinte maneira:

1
2
3
4
5
6

+-- wsl2-docker-devops/              #Pasta principal
    +-- 01_jenkins/                  #Todos os arquivos referente as configurações do jenkins
        +-- plugins/                 #Referencias aos arquivos de configuração de plugins
            +-- plugins.txt          #Arquivo com os nomes dos plugins a serem instalados
        +-- docker-compose.yml       #Configurações da aplicação
        +-- Dockerfile               #Construção da imagem.

Vamos alterar o arquivo docker-compose.yml com novas informações:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

version: "3.4"
volumes:
  jenkins_data:
    name: jenkins_data
services:
  jenkins:  
    build: .
    ports:
        - "8080:8080"
    volumes:
      - jenkins_data:/var/jenkins_home:rw

E vamos criar o arquivo Dockerfile:

1
2
3
4

FROM jenkins/jenkins:lts
COPY ./plugins/plugins.txt /usr/share/jenkins/ref/plugins.txt
RUN /usr/local/bin/install-plugins.sh < /usr/share/jenkins/ref/plugins.txt
ENV JAVA_OPTS="-Djenkins.install.runSetupWizard=false"

E um arquivo de texto plugins.txt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

cloudbees-folder
build-timeout
credentials
timestamper
ws-cleanup
ant
pipeline-milestone-step
pipeline-input-step
pipeline-stage-step
pipeline-graph-analysis
pipeline-rest-api
pipeline-stage-view
pipeline-build-step
pipeline-model-api
pipeline-model-extensions
pipeline-stage-tags-metadata
pipeline-model-declarative-agent
pipeline-model-definition
github-api
git
github
github-branch-source
ssh-credentials
ssh-slaves
build-user-vars-plugin
matrix-auth
pam-auth
ldap
email-ext
mailer

Ao executar o comando docker-compose up & dentro do diretório 01_jenkins, ao acessar a página http://localhost:8080 irá aparecer a tela inicial do jenkins, sem nenhuma configuração manual:

Através de um único comando, você construiu a imagem com os plugins e subiu o jenkins sem nenhuma interação! :wink:

Detalhe das Configurações

Docker-compose

Dentro do docker-compose.yaml definimos um Volume com um nome customizado chamado jenkins_data

volumes:
  jenkins_data:
    name: jenkins_data

Este nome de volume será utilizado dentro do serviço do jenkins, referenciando o caminho /var/jenkins_home:

    volumes:
      - jenkins_data:/var/jenkins_home:rw

Isto faz com que o volume criado tenha o nome jenkins_data e agora não importa quantas vezes você realize os comandos docker-compose up e docker-compose down, haverá somente 1 volume criado:

O último trecho é a configuração de build, onde indica que há um dockerfile e que ele devemos realizar a compilação do container, no caso de não existir:

services:
  jenkins:  
    build: .

Dockerfile

No Dockerfile , temos a configuração e execução do trecho que instala os plugins do jenkins:

COPY ./plugins/plugins.txt /usr/share/jenkins/ref/plugins.txt
RUN /usr/local/bin/install-plugins.sh < /usr/share/jenkins/ref/plugins.txt

A imagem oficial do Jenkins contém um script chamado install-plubins.sh onde realiza automaticamente o download e a instalação dos plugins listados no arquivo plugins.txt. Este script também instala os plugins dependentes, caso tenha algum.

Por fim, o último comando define o modo de inicialização do jenkins:

ENV JAVA_OPTS="-Djenkins.install.runSetupWizard=false"

O padrão de inicialização do jenkins segue o seguinte formato:

java <JAVA_OPTS> -jar jenkins.war <JENKINS_OPTS>

onde:

• JAVA_OPTS - Parâmetros da JVM

• JENKINS_OPTS - Parâmetros de inicialização do Jenkins

O parâmetro -Djenkins.install.runSetupWizard=false pula o Wizard de instalação do jenkins, porém deixa o jenkins sem nenhuma autenticação.

Nunca, nunca utilize as configurações deste modo em produção. Este Setup é somente para uso local e estudos. Futuramente iremos tratar de assuntos relacionados a execução do jenkins em produção.

Criando usuário Admin

Como estamos tratando as configurações como código, precisamos de um script inicial para criar o usuário admin. Para isto, vamos criar uma pasta groovy e criar o arquivo setup-users.groovy

1
2
3
4
5
6
7
8

+-- wsl2-docker-devops/              # Pasta principal
    +-- 01_jenkins/                  # Todos os arquivos referente as configurações do jenkins
        +-- plugins/                 # Referencias aos arquivos de configuração de plugins
            +-- plugins.txt          # Arquivo com os nomes dos plugins a serem instalados
        +-- groovy/                  # Referencias aos arquivos de configuração do Jenkins
            +-- setup-users.groovy   # Script para criação de usuários
        +-- docker-compose.yml       # Configurações da aplicação
        +-- Dockerfile               # Construção da imagem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import jenkins.model.*
import hudson.security.*

def instance = Jenkins.getInstance()

def hudsonRealm = new HudsonPrivateSecurityRealm(false)
hudsonRealm.createAccount("admin","password")
instance.setSecurityRealm(hudsonRealm)
instance.save()

def strategy = new GlobalMatrixAuthorizationStrategy()
strategy.add(Jenkins.ADMINISTER, "admin")
instance.setAuthorizationStrategy(strategy)

E vamos adicionar o mapeamento desta pasta no dockerfile:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

version: "3.4"
volumes:
  jenkins_data:
    name: jenkins_data
services:
  jenkins:  
    build: .
    ports:
        - "8080:8080"
    volumes:
      - ./groovy:/var/jenkins_home/init.groovy.d
      - jenkins_data:/var/jenkins_home:rw

Executando novamente docker-compose up & no terminal e acessando http://localhost:8080 teremos a tela de login do jenkins:

Acessando com login admin e senha password temos acesso ao jenkins!

Grande parte dos itens programáveis dentro do jenkins são realizados utilizando groovy como linguagem de programação. Dentro do jenkins existem alguns pontos de extensão onde podemos executar scripts groovy personalizados. Um ponto de extensão fica na inicialização do Jenkins, criando arquivos dentro da pasta init.groovy.d. Todos os scripts desta pasta serão executados.

O script setup-users.groovy cria o usuário admin e utilizamos o sistema de permissão de matriz para definirmos como administrador do jenkins.

Você pode ver o usuário criado acessando a base interna de usuários (Jenkins » Gerenciar Jenkins » Gerenciar Usuários) e as atribuições de administrador em Configurar Segurança Global (Jenkins » Gerenciar Jenkins » configurar Segurança Global).

!User Configurations](docker_jenkins_07.png)

Nos próximos artigos veremos como criar um job e as configurações necessárias para compilar uma aplicação em java.

Caso tenha alguma dúvida, ou uma sugestão, entre em contato.

Abraços!

Jenkins Logo by Jenkins Artwork