Pipeline Jenkins simples com maratona e mesos

1. Introdução

Neste artigo, implementaremos um pipeline de entrega contínua simples comJenkins,MarathoneMesos.

Primeiro, forneceremos uma visão geral de alto nível da pilha e da arquitetura de tecnologia, com uma explicação de como tudo se encaixa. Em seguida, passaremos para um exemplo prático passo a passo.

O resultado disso será um pipeline Jenkins totalmente automatizado, implantando nosso aplicativo em nosso cluster Mesos usando Marathon.

2. Visão geral da pilha de tecnologia

Ao trabalhar com contêineres e arquiteturas de microsserviço, enfrentamos novos problemas operacionais que não teríamos resolvido com as pilhas mais tradicionais.

Por exemplo, ao implantar em um cluster, precisamos lidar com dimensionamento, failover, rede e muito mais. Esses problemas de computação distribuídos e difíceis podem ser resolvidos com kernels e agendadores distribuídos, como Apache Mesos e Marathon.

2.1. Mesos

Mesos, em termos mais simples, pode ser visto como o único servidor em que nossos aplicativos serão executados. Na realidade, temos um cluster, mas é essa abstração que o torna tão útil.

2.2. Maratona

Marathon é a estrutura usada para implantar nossos aplicativos no Mesos, resolvendo problemas difíceis para nós (verificação de integridade, escalonamento automático, failover, monitoramento etc.).

3. Configuração e instalação

Este artigo pressupõe que você já tenha Jenkins, Mesos e Marathon em execução. Se não for esse o caso, consulte a documentação oficial de cada um deles para saber como configurá-los. Sem isso, você não conseguirá implementar nenhuma das etapas do guia.

4. Nosso Pipeline de Entrega

Criaremos o seguinte pipeline Jenkins:

Não há nada particularmente complexo nessa abordagem - é sinônimo de fluir da maioria dos pipelines de CD modernos. No nosso caso, construir significará o contêiner do aplicativo e implantar o uso do Marathon para agendá-lo em um cluster do Mesos.

5. Testando e construindo nosso aplicativo

O primeiro passo é criar e testar nosso aplicativo. Para simplificar, o aplicativo com o qual trabalharemos é um aplicativo Spring Boot. Por esse motivo, nosso artefato resultante será um jar executável. Não terá dependências externas além do JRE, tornando-o muito simples de executar.

5.1. Criando Nosso Trabalho

A primeira coisa que queremos fazer é criar nosso trabalho Jenkins. Vamos selecionar "Novo item" na barra de navegação à esquerda e, em seguida, selecione criar um projeto de estilo livre, nomeando-o "marathon-mesos-demo":

5.2. Integrando com Git

A seguir, vamos configurá-lo paraclone the Github repository contendo nosso aplicativo:

Para simplificar, nosso repositório é público, o que significa que podemos clonar em https.. Se esse não fosse o caso e estivéssemos clonando em SSH, haveria uma etapa adicional para configurar um SSH usuário e chave privada, além do escopo deste artigo.

5.3. Configurando acionadores de compilação

A seguir, vamos configurar alguns gatilhos de construção para que nosso trabalho pesquise o git por novos commits a cada minuto:

5.4. Gerando nosso script de construção

Agora podemos dizer ao nosso trabalho para executar um shell script quando ele for executado. Como estamos trabalhando com um projeto Spring Boot Maven simples, tudo o que precisamos fazer é executar o comando “mvn clean install“. Isso executará todos os testes e construirá nosso jar executável:

5.5. Construindo Nosso Projeto

Agora que configuramos o início do nosso pipeline, vamos acioná-lo manualmente clicando em “Construir agora” no trabalho. Quando o trabalho estiver concluído, podemos confirmar que ele passou sendo marcado como azul.

6. Contentorizando nosso aplicativo

Vamos para o próximo estágio do nosso pipeline, que é empacotar e publicar nosso aplicativo com o Docker. Precisamos usar o Docker, pois os contêineres são especificamente o que a Marathon gerencia. Isso é razoável, pois praticamente qualquer coisa pode ser executada em um contêiner. É mais fácil para uma ferramenta como o Marathon trabalhar com a abstração concedida por eles.

6.1. Criando o Dockerfile

Primeiro, vamos criar umDockerfile na raiz do projeto. Essencialmente, um Dockerfile é um arquivo que contém instruções para o Docker Deamon sobre como criar uma imagem:

FROM openjdk:8-jre-alpine
ADD target/mesos-marathon-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8082
ENTRYPOINT ["java","-jar","/app.jar"]

A imagem que estamos construindo é simples - tudo o que ela contém é um jar executável e um comando shell que o executará quando o contêiner iniciar. Também precisamos garantir que estamos expondo a porta na qual nosso aplicativo escutará, neste caso '8082'.

6.2. Publicação da imagem

Agora que podemos construir nossa imagem, vamos criar um script bash simples que o constrói e publica em nosso repositórioDocker Hub privado e o coloca na raiz do projeto:

#!/usr/bin/env bash
set -e
docker login -u example -p $DOCKER_PASSWORD
docker build -t example/mesos-marathon-demo:$BUILD_NUMBER .
docker push example/mesos-marathon-demo:$BUILD_NUMBER

Pode ser necessário enviar sua imagem ao registro da janela de encaixe pública ou à sua privada.

A variável de ambiente$BUILD_NUMBER é preenchida pelo Jenkins, incrementando a cada construção. Embora um pouco frágil, é uma maneira rápida de aumentar o número de versões de cada build. O$DOCKER_PASSWORD também é preenchido pelo Jenkins e, neste caso, usaremosEnvInject plugin para mantê-lo em segredo.

Embora pudéssemos armazenar esse script diretamente no Jenkins, é uma prática melhor que ele permaneça no controle de versão, já que ele pode ser versionado e auditado junto com o resto do nosso projeto.

6.3. Construindo e publicando no Jenkins

Agora vamos modificar nosso trabalho do Jenkins para que ele execute “Dockerise.sh” após construir o jar:

E então, vamos executar nosso trabalho para confirmar novamente, confirmando que tudo está funcionando ao ficar azul.

7. Implantando nossa imagem

Nosso pipeline está quase completo. Há apenas mais um estágio: usar o Marathon para implantar nosso aplicativo em nosso cluster Mesos.

O Jenkins vem com um plug-in "https://wiki.jenkins-ci.org/display/JENKINS/Marathon+Plugin[Distribuir com o Marathon]". Isso funciona como um invólucro em torno da API Marathon, tornando mais fácil do que seria ao trabalhar com scripts de shell tradicionais. Você pode instalá-lo através do gerenciador de plugins.

7.1. Criando nosso arquivo Marathon.Json

Antes de podermos usar o plugin Marathon, precisamos criar um arquivo "marathon.json" e armazená-lo na raiz do projeto. Isso ocorre porque o plugin depende dele.

Este arquivo: “marathon.json” contém umMesos Application Definition. Esta é uma descrição de um serviço (aplicativo) de longa execução que queremos executar. Por fim, o plug-in Jenkins Marathon fará o POST do conteúdo do arquivo no endpoint do Marathon/v2/apps. O Marathon, por sua vez, agendará o aplicativo definido para execução no Mesos:

{
  "id": "mesos-marathon-demo",
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "",
      "network": "BRIDGE",
      "portMappings": [
        { "containerPort": 8082, "hostPort": 0 }
      ]
    }
  }
}

Essa é a configuração mais simples que podemos oferecer para um aplicativo em contêiner.

A propriedade: “portMappings” precisa ser configurada corretamente para tornar nosso aplicativo acessível a partir de nosso escravo Mesos. Basicamente, significa mapear a porta do contêiner8082, para uma porta aleatória no host (mesos escravo) para que possamos conversar com nosso aplicativo do mundo externo. Depois de implantar nosso aplicativo, o Marathon nos dirá o que essa porta usou.

7.2. Adicionando uma etapa de compilação de implantação de maratona

Vamos adicionar uma ação pós-construção da implantação da maratona ao nosso trabalho:

Observe que estamos informando ao plug-in onde o Marathon está sendo executado, neste caso ‘localhost: 8081’. Também estamos dizendo a ele a imagem que queremos implantar. É por isso que o campo "imagem" vazio em nosso arquivo é substituído.

Agora que criamos o estágio final de nosso pipeline, vamos executar nosso trabalho mais uma vez e confirmar que ainda está passando, desta vez com a etapa extra em que envia nosso aplicativo para o Marathon.

7.3. Verificando nossa implantação em Maratona

Agora que foi implantado, vamos dar uma olhada na IU do Marathon:

Como podemos ver, nosso aplicativo agora é mostrado na interface do usuário. Para acessá-lo, basta verificar qual host e porta foi atribuída:

Nesse caso, foi alocada aleatoriamente a porta 31143 no localhost, que será mapeada internamente para a porta 8082 em nosso contêiner, conforme configurado na definição do aplicativo. Em seguida, podemos visitar este URL em nosso navegador para confirmar se o aplicativo está sendo veiculado corretamente.

8. Conclusão

Neste artigo, criamos um pipeline de entrega contínua simples usando Jenkins, Marathon e Mesos. Sempre que fizermos uma alteração em nosso código, ele será executado em um ambiente alguns minutos depois.

Os artigos posteriores desta série abordarão tópicos mais avançados da Maratona, como verificação de integridade do aplicativo, dimensionamento e failover. Outros casos de uso do Mesos, como o processamento em lote, também podem ser abordados.

O código-fonte do nosso aplicativo está disponível emover on GitHub; este é um projeto Maven que deve ser executado como está.

TOC

Pipeline Jenkins simples com maratona e mesos