Jenkins no Kubernetes Engine

Neste tópico, você aprende usar as práticas recomendadas para usar o Jenkins com o Google Kubernetes Engine. Para implementar essa solução, consulte como configurar o Jenkins no Kubernetes Engine.

Com o Jenkins, um servidor de automação de código aberto, é possível orquestrar os pipelines de criação, teste e implantação de maneira flexível. O Kubernetes Engine é uma versão hospedada do Kubernetes, um poderoso gerenciador de cluster e de sistema de orquestração de contêineres.

Quando é preciso configurar um canal de entrega contínua (CD, na sigla em inglês), a implantação do Jenkins no Kubernetes Engine oferece benefícios importantes em relação a uma implantação padrão baseada em VM:

  • Quando o processo de compilação usa contêineres, um host virtual pode executar jobs em diferentes sistemas operacionais.

  • O Kubernetes Engine oferece executores de criação temporários, permitindo que cada criação seja executada em um ambiente limpo, idêntico às criações anteriores.

    • Como esses executores são temporários, o cluster do Kubernetes Engine só é utilizado quando as criações estão ativamente em execução, disponibilizando recursos para outras tarefas de cluster, como jobs de processamento em lote.

    • Os executores de compilação são iniciados em questão de segundos.

  • O Kubernetes Engine usa o Balanceador de carga global do Google para rotear o tráfego da Web para sua instância. O balanceador de carga processa a terminação SSL e fornece um endereço IP global que encaminha os usuários para o front-end da Web em um dos caminhos mais rápidos do ponto de presença mais próximo dos usuários por meio da rede backbone do Google.

Como implantar os clusters do Kubernetes Engine

Ao implantar um cluster do Kubernetes Engine, ative os escopos de autenticação para os serviços a seguir.

  • Google Cloud Storage — storage-rw

    • O Jenkins precisa acessar o Google Container Registry, um serviço que armazena conteúdo no Google Cloud Storage.
  • Google Cloud Source Repositories — projecthosting

    • O Cloud Source Repositories oferece repositórios particulares que podem ser usados para o código-fonte. O Jenkins pode extrair desses repositórios para criar, testar e implantar o código o mais rápido possível.

Por exemplo, quando criar um cluster, você pode usar um código semelhante a este:

gcloud container clusters create jenkins-cd \
         --network jenkins \
         --scopes "https://www.googleapis.com/auth/projecthosting,storage-rw"

Se você planeja utilizar outros serviços do Google, pode adicionar escopos adicionais.

Implantar o Jenkins Master

A imagem a seguir descreve a arquitetura da implantação do Jenkins em um cluster Kubernetes de vários nodes.

Arquitetura do Jenkins e Kubernetes

Implante o Jenkins Master em um namespace no cluster do Kubernetes. Os namespaces permitem criar cotas para a implantação do Jenkins, bem como separar logicamente o Jenkins de outras implantações dentro do cluster.

Para criar um namespace Kubernetes, digite o seguinte comando.

kubectl create namespace jenkins

Criar os serviços Jenkins

O Jenkins fornece dois serviços que o cluster precisa acessar. Implante esses serviços separadamente para serem gerenciados e nomeados individualmente.

  • Um serviço NodePort exposto externamente na porta 8080 que permite que pods e usuários externos acessem a interface do usuário do Jenkins. Esse tipo de serviço pode ser carregado por um balanceador de carga HTTP.

  • Um serviço ClusterIP particular interno na porta 50000 que os executores do Jenkins usam para se comunicar com o Jenkins Master dentro do cluster.

As seções a seguir mostram as definições de serviço de exemplo.

---
  kind: Service
  apiVersion: v1
  metadata:
    name: jenkins-ui
    namespace: jenkins
  spec:
    type: NodePort
    selector:
      app: master
    ports:
      - protocol: TCP
        port: 8080
        targetPort: 8080
        name: ui
---
  kind: Service
  apiVersion: v1
  metadata:
    name: jenkins-discovery
    namespace: jenkins
  spec:
    selector:
      app: master
    ports:
      - protocol: TCP
        port: 50000
        targetPort: 50000
        name: slaves

Criar a implantação do Jenkins

Implante o mestre do Jenkins como uma implantação com uma contagem de réplicas de 1. Isso garante que haja um único Jenkins Master em execução no cluster em todos os momentos. Se os dados do pod do Jenkins Master ou o node em execução forem encerrados, o Kubernetes reiniciará o pod em outro lugar do cluster.

É importante definir solicitações e limites como parte da definição de implantação. Assim, o contêiner terá uma determinada quantidade de recursos de memória e CPU no cluster antes de ser programado. Caso contrário, o master pode deixar de funcionar por privação da CPU ou memória.

O volume inicial do Jenkins armazena arquivos de configuração XML e arquivos JAR de plug-in que compõem a configuração. Considere as seguintes práticas recomendadas.

  • Crie um disco permanente para armazenar o diretório inicial. Isso garante que os dados de configuração críticos serão mantidos, mesmo que o pod que executa o Jenkins Master pare de funcionar.

  • O disco deve ser maior que ou igual a 10 GB.

  • Depois da criação do volume, formate o volume anexando-o a uma máquina virtual. Em seguida, desative o volume de qualquer máquina virtual e desanexe-o. Você pode usar o volume em sua implantação.

O código a seguir descreve uma definição de implantação de exemplo.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: jenkins
  namespace: jenkins
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: master
    spec:
      containers:
      - name: master
        image: jenkins/jenkins:2.67
        ports:
        - containerPort: 8080
        - containerPort: 50000
        readinessProbe:
          httpGet:
            path: /login
            port: 8080
          periodSeconds: 10
          timeoutSeconds: 5
          successThreshold: 2
          failureThreshold: 5
        env:
        - name: JENKINS_OPTS
          valueFrom:
            secretKeyRef:
              name: jenkins
              key: options
        - name: JAVA_OPTS
          value: '-Xmx1400m'
        volumeMounts:
        - mountPath: /var/jenkins_home
          name: jenkins-home
        resources:
          limits:
            cpu: 500m
            memory: 1500Mi
          requests:
            cpu: 500m
            memory: 1500Mi
      volumes:
      - name: jenkins-home
        gcePersistentDisk:
          pdName: jenkins-home
          fsType: ext4
          partition: 1

Conectar ao Jenkins

Todos os pods no cluster Kubernetes podem acessar a interface do usuário do Jenkins usando master.jenkins.svc como o nome do host e 8080 como a porta.

Uma vez que o pod do Jenkins foi criado, você pode criar um node de ponto extremidade do balanceador de carga para se conectar a ele de fora do Cloud Platform. Considere as seguintes práticas recomendadas.

  • Use um recurso de entrada do Kubernetes para um balanceador de carga L7 fácil de configurar com terminação SSL.

  • Forneça certificados SSL ao balanceador de carga usando os segredos do Kubernetes. Use tls.cert e tls.key e faça referência a esses valores na configuração de recursos de entrada.

Configurar o Jenkins

Proteger o Jenkins

Depois de se conectar ao Jenkins pela primeira vez, é importante torná-lo seguro imediatamente. Siga o tutorial de configuração de segurança padrão do Jenkins para um procedimento simples que utiliza um banco de dados interno de usuários. Essa configuração não requer infraestrutura adicional e oferece a capacidade de bloquear usuários anônimos.

Como instalar plug-ins

Instale os seguintes plug-ins para aprimorar as interações entre o Jenkins e o Kubernetes Engine.

  • Com o plug-in do Kubernetes, é possível usar contas do serviço Kubernetes para autenticação e criação de configurações do executor rotuladas com diferentes imagens de base. O plug-in cria um pod quando um executor é necessário e o destrói quando um job termina.

  • O plug-in Google Authenticated Source permite usar as credenciais da conta de serviço ao acessar os serviços do Cloud Platform, como o Cloud Source Repositories.

Instale os plug-ins seguindo essas instruções.

Como configurar o Jenkins para o Kubernetes Engine

Para instruções detalhadas sobre como configurar o Jenkins para o Kubernetes Engine, inclusive como configurar o executor de criação, adicionar credenciais e muito mais, consulte Como configurar o Jenkins para o Kubernetes Engine.

Como personalizar a imagem do Docker

Ao criar um modelo de pod, você pode fornecer uma imagem do Docker existente ou criar uma imagem personalizada que tenha instalada a maioria das dependências de tempo de compilação. Usar uma imagem personalizada pode diminuir o tempo total de compilação e criar ambientes de compilação mais consistentes.

A imagem do Docker personalizada instala e configura o agente escravo do Jenkins JNLP. O agente JNLP é um software que se comunica com o mestre do Jenkins para coordenar a execução dos jobs do Jenkins e informar o status do job.

Uma opção é adicionar FROM jenkins/jnlp-slave à configuração de imagem. Por exemplo, se o processo de compilação do aplicativo depender do ambiente de execução do Go, você poderá criar o seguinte Dockerfile para ampliar a imagem existente com suas próprias dependências e criar artefatos.

FROM jenkins/jnlp-slave
RUN apt-get update && apt-get install -y golang

Em seguida, crie e faça o upload da imagem para o repositório do Container Registry do projeto executando os seguintes comandos.

docker build -t gcr.io/[PROJECT]/my-jenkins-image .
gcloud docker -- push gcr.io/[PROJECT]/my-jenkins-image

Ao criar um modelo de pod, configure o campo Imagem do Docker para a string a seguir, em que [PROJECT] é substituído pelo nome do projeto, e [IMAGE_NAME], pelo nome da imagem.

gcr.io/[PROJECT]/[IMAGE_NAME]

O exemplo acima garante que o tempo de execução da linguagem do Go seja pré-instalado quando o job do Jenkins for iniciado.

Fazer o upgrade do Jenkins

Para fazer o upgrade do mestre do Jenkins, edite o manifesto de implantação e altere o valor da tag da propriedade image para a versão de upgrade desejada. Para uma lista das versões disponíveis, consulte a lista de tags de imagens do Jenkins do Docker.

Depois de editar o arquivo, implante a alteração usando o seguinte comando.

kubectl apply -f jenkins.yaml

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…