Riot Games

neste primeiro tutorial na série Docker, você vai aprender:

• o Que estamos tentando realizar no Motim

• configuração Básica para a janela de Encaixe

• Básica janela de Encaixe Puxar Comandos

• Como executar a janela de Encaixe Recipientes como Daemons

• Básica Jenkins opções de configuração

Quando eu comecei a aprender sobre a janela de Encaixe de um ano atrás e explorar o seu uso eu tinha dificuldade em encontrar grandes documentação e exemplos -, ainda hoje, muitos descrevem simples casos de uso que, em última análise, não está pronto para produção. A produção de aplicações com recipientes de acoplagem requer ajuste à sua natureza efêmera e foco de processo único. Isto apresenta desafios para aplicações com necessidades de persistência de dados ou arquiteturas multi-processos.

como mencionei no meu último post, usamos Jenkins como uma peça fundamental de software de código aberto em cima do qual construímos nossa automação. Jenkins também é uma ótima aplicação para demonstrar uma maneira de pensar sobre” Dockerizing ” suas aplicações. Implantamos o Jenkins com estes componentes arquitectónicos em mente.:

• Jenkins servidor mestre (Java processo)

• Jenkins (dados mestre (Plugins, Definições de Trabalho, etc.)

• NGINX de proxy da web (podemos usar SSL certificados etc, com NGINX é uma escolha fácil aqui)

• Construir escravo agentes (máquinas, sendo SSH seria em, ou JNLP ligar, Jenkins Mestre)

Este é um bom lugar para começar. Sobre esta série de posts do blog eu estarei cobrindo maneiras de pensar sobre todos OS acima como contêineres e terminar com um olhar avançado em maneiras de usar contêineres do Docker como escravos de construção. Para começar, vamos criar um servidor-mestre Jenkins num contentor do Docker. Então vamos passar a lidar com a persistência dos dados e adicionar um proxy web com a NGINX.

toda esta série de blogs irá cobrir os seguintes conceitos de Docker:

• Fazer a sua própria Dockerfiles

• Minimizar imagem dependências imagens públicas

• a Criação e o uso de Dados-Volumes, incluindo cópias de segurança

• a Criação de contêineres “Criar Ambientes” usando recipientes

• Manipulação de “segredo” de dados com imagens e Jenkins

Se você não tiver um olhar para o Cloudbees Jenkins janela de Encaixe imagem, inicie lá é realmente muito bom. Este foi o meu ponto de referência quando, pela primeira vez, pensei em colocar o Jenkins num contentor de ancoragem e, para muitas pessoas, isto pode ser suficiente. Você pode encontrar a documentação deles aqui e o seu git repo/Dockerfile aqui.

este primeiro blog é dividido em dois planos de lição. Cada um é dimensionado para levar cerca de 30 minutos para completar. Em primeiro lugar, a parte um está preparando seu ambiente de desenvolvimento e aprendendo a trabalhar com o contêiner Jenkins Docker padrão que Cloudbees oferece. A segunda parte é sobre como preparar o terreno para embrulhar esta imagem no seu próprio ficheiro de Dockerfile e tomar um controlo mais elegante da imagem. Juntos eles são projetados para começar você, especialmente se você nunca trabalhou com o Docker antes ou são relativamente novos para o Docker—embora eles presumam que você já sabe e entende como trabalhar com o Jenkins. Se você é experiente com o Docker, algum do material da Lição 1 será um pouco de uma repetição de coisas que você provavelmente já sabe.

lição 1: Configurar e executar a sua primeira imagem

vamos prepará-lo para rolar. Aqui no Riot trabalhamos com o Docker (e Jenkins) no Windows, Mac OSX e Linux. Prefiro trabalhar com o Docker no OSX, embora seja perfeitamente funcional no Windows desde o Docker 1.6. Atualmente, existem excelentes instaladores para ambos os sistemas operacionais. Vou trabalhar de uma perspectiva OSX, mas as mesmas ferramentas existem para o Windows.

PRÉ-REQUISITOS:

1. Você precisará do Windows 10 Pro ou Mac OSX Yosemite 10.10.3 (ou mais tarde)

2. Se usar o Windows, terá de ter a certeza de que tem a virtualização do Windows activa (veja a documentação que o Docker oferece)

uma nota rápida sobre o KITEMATIC

com o Docker 1.8 e o lançamento da caixa de ferramentas do Docker, o Docker agora inclui “Kitematic”, uma ferramenta de GUI nifty para ajudar a gerir e visualizar o que está a acontecer com as suas imagens e contentores do Docker. A maioria deste tutorial se concentra em usar argumentos de linha de comando e trabalhar com o Docker sem a GUI Kitemática. Isto é para melhor expô-lo aos mecanismos subjacentes. Da mesma forma, em blogs posteriores eu começo a cobrir o uso da composição para iniciar e parar vários contêineres de uma só vez.

STEP 1: INSTALL DOCKER

1. Ir para: https://www.docker.com/docker-mac ou https://www.docker.com/docker-windows

2. Faça o Download e instale a versão apropriada do Docker para o seu sistema operativo

3. Siga todas as instruções de configuração.

4. Verifique se a sua instalação está a funcionar, abrindo a linha de comandos recomendada para o seu SO (Terminal para o OSX, Powershell para o windows), executando o “terminal de arranque rápido do Docker”. No Windows, este será um atalho na sua área de trabalho. No OSX, você vai encontrá-lo em sua pasta applications/Docker. Verifique os seguintes comandos e certifique-se de que não recebe quaisquer erros

docker ps

docker info

5. Antes de fazermos qualquer outra coisa, devemos aumentar a memória padrão e configurações de CPU que o Docker usa. Mais tarde vamos sintonizar o Jenkins para usar mais memória e se não ajustarmos estas configurações primeiro, o Jenkins pode falhar.

• Vá para a sua janela de Encaixe widget na barra de ferramentas e selecione “Preferências”

• Vá para a guia configuração Avançada

• Aumentar a utilização da CPU para pelo menos 4 núcleos

6. Aumente o uso da memória para pelo menos 8GB, preferencialmente mais, algo como 12GB para ser seguro (se você tem disponível)

Passo 2: Puxe e execute o CONTAINER CloudBees JENKINS

1. Fica na janela do Terminal Docker.

2. Tira o Jenkins do repo público correndo:

docker pull jenkins/jenkins

docker run -p 8080:8080 --name=jenkins-master jenkins/jenkins

3. Note que a mensagem” configuração inicial Jenkins ” na sua janela da shell irá gerar uma senha para si. Escreve isso porque vais precisar mais tarde. Se o perder, poderá executar o ‘ docker exec jenkins-master cat /var/jenkins_home/secrets/initial AdminPassword` com o seu contentor a correr para o recuperar.

4. Abra o seu navegador favorito e aponte-o para http://localhost:8080

por favor, note, você verá que eu uso o acoplador –nome da bandeira e nome do container jenkins-master – esta é uma convenção que vou usar ao longo deste blog. Nomear seus contêineres é uma boa prática útil com três benefícios:

1. Torna-os fáceis de lembrar e interagir com

2. O Docker não permite que dois recipientes tenham o mesmo nome, o que evita erros como acidentalmente iniciar dois recipientes idênticos

3. Muitas ferramentas comuns do Docker (como a composição do Docker) usam nomes de contêineres específicos, então se acostumar a nomear seus contêineres é uma boa melhor prática.

Passo 3: tornando isto um pouco mais prático

o passo anterior inicia Jenkins com as suas configurações mais básicas de arranque. Você pode até ver que o Jenkins precisa de configuração básica e está a pedir-lhe uma senha de administrador (que pode obter a partir dos registos que aparecem na sua tela durante a inicialização). Se você é como O Riot, é improvável que você execute o Jenkins em configurações padrão. Vamos adicionar algumas opções úteis. Ainda não nos vamos dar ao trabalho de configurar o Jenkins; é o suficiente para saber que ele pode começar e correr.

STEP 3A: DAEMONIZAR

você provavelmente não quer ver os toros Jenkins cuspirem para Padrão na maior parte do tempo. Então use a bandeira do servidor do Docker para iniciar o container (-d).

1. Ctrl – C na janela de terminal a correr o seu contentor para o parar

2. Executar os seguintes comandos

docker rm jenkins-master

docker run -p 8080:8080 --name=jenkins-master -d jenkins/jenkins

agora você deve apenas obter um hash string exibido e ser devolvido ao seu terminal. Se você é novo no Docker, essa cadeia de hash é na verdade o ID único do seu container (útil se você começar a automatizar esses comandos).

STEP 3B: MEMORY SETTINGS

we tender to run Jenkins with some beefy settings at Riot. Lembras-te quando aumentaste o CPU/memória que o Docker usa mais cedo? Esta é a principal razão. Para um início básico, execute os seguintes comandos

docker stop jenkins-master

docker rm jenkins-master

docker run -p 8080:8080 --name=jenkins-master -d --env JAVA_OPTS="-Xmx8192m" jenkins/jenkins

isso deve dar ao Jenkins uma piscina de memória de 8 GB e espaço para tratar da recolha de lixo.

STEP 3C: INCREASING THE CONNECTION POOL

At Riot, we get a lot of traffic to our Jenkins server, so we’ve learned to give Jenkins a bit more breathing room. Executar o seguinte

docker stop jenkins-master

docker rm jenkins-master

Isso dará ao Jenkins uma bela base de tratadores e um boné. Coincidentemente você agora aprendeu a usar tanto JAVA OPTS quanto JENKINS como variáveis de ambiente de uma forma significativa. Por favor, note que isto funciona devido à forma como os Cloudbees convenientemente estruturaram o seu ficheiro Jenkins Dockerfile.

Passo 4: juntar tudo

coloquei tudo o que aprendemos aqui num makefile simples para que possa usar os comandos make para controlar a execução do seu contentor do acoplador Jenkins. Você pode encontrá-lo aqui:

• https://github.com/maxfields2000/docker Jenkins_tutorial/tree/master/tutorial_01

Você pode usar os seguintes comandos:

• fazer build – Puxa o Jenkins imagem

• fazer execute – Executa o recipiente

• fazer stop – Pára o recipiente

• fazer a limpa – Pára e elimina o recipiente existente

Você não precisa usar o makefile, Eu só acho que é mais fácil do que digitar todo o comando executar. Você poderia facilmente colocar estes em um script de sua escolha em vez disso.

esperançosamente você vê como é fácil se levantar e correr com Docker e Jenkins. Eu tentei dar-lhe algumas opções básicas para pegar o contêiner Cloudbees Jenkins padrão e torná-lo um pouco mais utilizável. Cloudbees tem muitos tutoriais úteis para executar seu contêiner, como como pré-instalar plugins e armazenar dados Jenkins.Isso me leva a futuros posts sobre o assunto. Este container / imagem é útil, mas tem algumas desvantagens: nenhum registro consistente, nenhuma persistência, nenhum proxy de servidor web na frente dele, e nenhuma maneira limpa de garantir que você use a versão de Jenkins que você deseja. Isto levanta questões como: e se você quiser manter uma versão mais antiga? Ou e se você quiser usar o último período de lançamento disponível?

na próxima lição vou cobrir tornando este recipiente um pouco mais robusto. Em especial:

• Criar o seu próprio Dockerfile para moldar o Cloudbees base

• Movendo-se algumas variáveis de ambiente para esta nova imagem

• Criar uma pasta de log, configuração de permissões e outros útil Jenkins diretórios, e recuperar o Backup, de logs durante a sua execução

LIÇÃO 2 – UM BACKUP da BASE de dados de IMAGEM de WRAPPER

Na lição anterior abordei a configuração de um ambiente de desenvolvimento para executar a janela de Encaixe e experimentou com o Jenkins janela de Encaixe imagem fornecida pelo Cloudbees. Descobrimos que era simples e fácil de usar, com algumas grandes características fora da caixa. Para fazer progressos nas áreas de melhoria identificado, a janela de Encaixe conceitos abordados nesta lição são:

• Fazer a sua própria Dockerfile

• Definição de variáveis de ambiente em um Dockerfile

• Criação de pastas e permissões em um Dockerfile

• Usando a janela de encaixe exec para executar comandos em um recipiente de execução

FAZENDO a SUA BASE DOCKERFILE

queremos fazer algumas alterações à forma como o Backup é iniciado por padrão. No último blog nós lidamos com isso criando um makefile que passou em argumentos como variáveis de ambiente. Dado que queremos fazer isto todas as vezes, podemos colocá-los no nosso próprio ficheiro. Além disso, nosso próprio Dockerfile nos permitirá bloquear a versão de Jenkins que estamos usando no caso de Cloudbees atualizar o deles e não estamos prontos para atualizar.

fazemos isto em quatro etapas:

1. Criar uma pasta de trabalho

2. No seu editor de texto favorito, crie um novo ficheiro chamado “Dockerfile”

3. Adicionar o seguinte ao ficheiro e gravá – lo:

FROM jenkins/jenkins:2.112LABEL maintainer=""

4. Em seguida, na linha de comando enter:

docker build -t myjenkins .

o que fizemos aqui foi tirar uma versão em particular da imagem Jenkins da public docker repo. Você encontrará todas as versões disponíveis aqui:

• você pode sempre definir a cláusula de FROM para ser qualquer versão da imagem está disponível. No entanto, você não pode simplesmente definir a versão para qualquer versão do Jenkins que você quer. Esta é a versão de imagem “tag” ou “label”, e Cloudbees é bom o suficiente para fazer com que corresponda à versão Jenkins dentro da imagem. Cloudbees oferece ” jenkins / jenkins “como uma maneira conveniente de obter a versão mais recente, ou” jenkins/jenkins:lts “para obter a versão mais recente de” suporte a longo prazo”. Neste exemplo eu uso uma versão específica. Estas marcas que rotulam tipos de lançamentos são grandes, mas usando-os significa que a versão de Jenkins pode mudar por baixo de você, o que pode causar complicações se você não estava pronto para atualizar. Eu recomendo “bloqueio de versão” como uma melhor prática geral ao lidar com quaisquer dependências em Docker ou outras ferramentas de gerenciamento de dependências. Queres que as coisas mudem quando queres, não antes. É por isso que uso uma versão específica aqui.

  TESTE com O NOVO DOCKERFILE

  podemos mudar para a imagem muito facilmente modificando a nossa janela de encaixe executar o comando para o seguinte:

  docker run -p 8080:8080 --name=jenkins-master -d --env JAVA_OPTS="-Xmx8192m" --env JENKINS_OPTS=" --handlerCountMax=300" myjenkins

  Agora podemos limpeza essas variáveis de ambiente, colocando-los em nosso próprio Dockerfile.

  adicionar variáveis de ambiente ao nosso ficheiro de DOCKERFILE

  é fácil adicionar definições predefinidas para coisas como variáveis de ambiente aos ficheiros de Dockerfiles. Isto também fornece uma bela peça de auto-documentação. E, porque você pode sempre sobrepor estes ao executar o recipiente Docker, não há realmente nenhuma desvantagem.

  1. No seu ficheiro de Dockerfile adicione as seguintes linhas a seguir à linha “manutenção” :

  ENV JAVA_OPTS="-Xmx8192m"ENV JENKINS_OPTS=" --handlerCountMax=300"

  2. Gravar e reconstruir a sua imagem:

  • docker build-t myjenkins .

  docker build -t myjenkins .

  muito simples! Você pode testar que funciona, ainda hoje, introduzindo os seguintes três comandos:

  docker stop jenkins-master

  docker rm jenkins-master

  docker run -p 8080:8080 --name=jenkins-master -d myjenkins

  

  Sua imagem deve começar até! Mas como é que sabes que as variáveis de ambiente funcionavam? Simples: da mesma forma que você verificaria para ver quais os argumentos iniciados seu aplicativo Jenkins normalmente usando ps. E isso funciona mesmo se você estiver desenvolvendo no Windows.

  EXECUÇÃO de UM COMANDO BÁSICO CONTRA o SEU RECIPIENTE

  Para confirmar que o Java e Jenkins opções estão definidas corretamente podemos executar ps em nosso recipiente e ver o Jenkins Java processo usando a janela de encaixe exec

  docker exec jenkins-master ps -ef | grep java

  Você deve ver algo similar a isso voltar

  jenkins 1 0 99 21:28 ? 00:00:35 java -Xmx8192m -jar /usr/share/jenkins/jenkins.war --handlerCountMax=300

  

  com isso, você pode facilmente ver a nossa configurações preso. docker exec é uma maneira simples de executar comandos shell dentro do seu container e também uma maneira incrivelmente simples de inspecioná-los. Isto ainda funciona no Windows porque, lembre-se, o comando após “exec” está sendo executado dentro do seu contêiner e, portanto, é baseado em qualquer imagem base que o seu contêiner usa.

  configurar uma pasta de Registo

  no blog anterior, notámos que perdemos visibilidade nos registos Jenkins ao executar o nosso contentor com a bandeira daemonize (-d). Queremos usar a funcionalidade incorporada no Jenkins para definir uma pasta de Registo. Vamos ter de fazer isto no nosso Dockerfile e passar a opção de registo para o Jenkins.Vamos editar o nosso Ficheiro de Dockerfile outra vez. Entre o “mantenedor” e a primeira linha ENV vamos adicionar o seguinte

  RUN mkdir /var/log/jenkins

  colocamos o comando neste local no arquivo para seguir as melhores práticas. É mais provável que vamos mudar as variáveis de ambiente do que estes diretórios de configuração, e cada linha de comando em um Dockerfile essencialmente se torna sua própria camada de imagem. Você maximiza a reutilização da camada colocando itens frequentemente alterados perto do fundo.Agora construa a sua imagem de novo:

  docker build -t myjenkins

  ---> Running in 0b5ac2bce13bmkdir: cannot create directory '/var/log/jenkins': Permission denied

  

  não te preocupes. Isto é porque o container padrão Cloudbees define o usuário em execução para o usuário” Jenkins”. Se você olhar para o seu Dockerfile (encontrada aqui: https://github.com/ Jenkinsci/encaixe/blob/master/Dockerfile) você deve ver, perto da parte inferior

  USER ${user}

  Esta sintaxe pode ser um pouco confuso. Ele usa os “argumentos” do Docker para permitir que você defina o usuário. Se você procurar mais acima o arquivo Docker você vai encontrar o valor padrão. Olhe perto do topo do ficheiro do Dockerfile para

  ARG user=jenkins

  isto cria o argumento do “utilizador” (ARG) e define-o para o utilizador Jenkins. Isto permite-lhe alterar o nome de utilizador que o Jenkins usa quando chama docker build –build-arg somevariável=somevalue. Note que isto só funciona se estiver a construir o ficheiro Dockerfile do zero. Você não pode alterar estes valores com um acoplamento ou uma corrida de acoplamento. Você pode ler mais sobre argumentos build aqui. Porque estamos usando uma versão prebuilt em nossa cláusula FROM, acabamos com o usuário padrão: “jenkins”.

  no Linux normal, você apenas usaria o SUDO ou algum outro meio para criar a pasta (/var/log é de propriedade do root). Felizmente para nós, o Docker permite-nos trocar de utilizadores.

  adicione o seguinte ao seu ficheiro de Dockerfile:

  1. Antes da sua linha mkdir correr adicionar

  USER root

  2. Após a sua linha mkdir correr adicionar

  RUN chown -R jenkins:jenkins /var/log/jenkins

  3. Após a sua linha de execução adicionar:

  USER jenkins

  Note que nós também tivemos que adicionar um comando chown porque nós queremos que o Usuário Jenkins seja capaz de escrever para a pasta. Em seguida, estabelecemos a root e, em seguida, reiniciamos Jenkins para que o comportamento do Dockerfile seja preservado.Agora construa a sua imagem de novo:

  docker build -t myjenkins .

  

  e….. os teus erros devem ter desaparecido.

  Com o diretório de log definido (nota: você pode colocar esta pasta onde quiser, nós o /var/log de consistência) podemos agora dizer-Jenkins para a gravação para essa pasta no arranque modificando o JENKINS_OPTS variáveis de ambiente.

  no seu ficheiro de Dockerfile edite a linha JENKINS_ OPTS para se parecer com esta:

  • ENV JENKINS_OPTS=” — handlerCountMax=300 — logfile=/var/log/jenkins / jenkins.registo”

  ENV JENKINS_OPTS="--handlerCountMax=300 --logfile=/var/log/jenkins/jenkins.log"

  crie Agora a sua imagem mais uma vez

  docker build -t myjenkins .

  Vamos testar a nossa nova imagem e se podemos cauda o arquivo de log! Tente os seguintes comandos

  docker stop jenkins-master

  docker rm jenkins-master

  docker run -p 8080:8080 --name=jenkins-master -d myjenkins

  Com o recipiente em execução podemos cauda o arquivo de log se tudo funcionou

  docker exec jenkins-master tail -f /var/log/jenkins/jenkins.log

  RECUPERAR LOGS SE JENKINS FALHA

  Tempo para uma ronda de bónus! Já que estamos a discutir registos, o Docker apresenta um problema interessante se o Jenkins se despenhar. O contentor deixará de funcionar e o docker exec deixará de funcionar. Então o que fazer?Discutiremos formas mais avançadas de persistir no ficheiro de Registo mais tarde. Por agora, como o container está parado, podemos copiar arquivos dele usando o comando cp docker. Vamos simular um acidente, parando o contêiner, em seguida, recuperando os registros:

  1. ctrl – C para sair do ficheiro de Registo cauda

  2. Execute os seguintes comandos

  docker stop jenkins-master

  docker cp jenkins-master:/var/log/jenkins/jenkins.log jenkins.log

  cat jenkins.log

  

  CONCLUINDO PENSAMENTOS

  Você pode encontrar todo o trabalho no meu tutorial repositório Git (e atualizado conveniência makefile) aqui:

  • https://github.com/maxfields2000/docker Jenkins_tutorial/tree/master/tutorial_02

  fazendo nossa própria Dockerfile que envolve o Cloudbees arquivo, fomos capazes de tornar a vida um pouco mais fácil para nós. Montamos um lugar conveniente para armazenar os registros e aprendemos a olhar para eles com o comando docker exec. Movemos nossas configurações padrão para o Dockerfile e agora podemos armazenar isso no controle de código como um bom pedaço de auto-documentação.

  ainda temos um desafio de persistência de dados. Aprendemos a tirar os ficheiros de registo de um contentor parado (útil quando o Jenkins cai). Mas, em geral, se o nosso contentor parar, ainda estamos a perder todos os empregos que criámos. Então, sem persistência, esta imagem Jenkins só é útil para o desenvolvimento local e testes.

  que nos leva ao próximo artigo. Com as nossas fundações no lugar – o nosso próprio invólucro do ficheiro Dockerfile, fechado a uma versão útil do Jenkins – podemos resolver o problema da persistência. O próximo artigo explorará estes conceitos:

  • Preservar Jenkins Trabalho e dados do Plugin

  • janela de Encaixe de Persistência de Dados com Volumes

  • Fazendo um Volume de Dados recipiente

  • Compartilhamento de dados em volumes com outros recipientes

  Para mais informações, confira o resto desta série:

  Parte I: o Pensamento Dentro do Recipiente
  Parte II: Colocar Jenkins, em uma janela de Encaixe Recipiente (este artigo)
  Parte III: janela de Encaixe & Jenkins: Dados Que Persiste
  Parte IV: Jenkins, a janela de Encaixe, Proxies, e Compor
  Parte V: Taking Control of Your Docker Image
  Part VI: Building with Jenkins Inside an Ephemeral Docker Container
  Part VII: Tutorial: Building with Jenkins Inside an Ephemeral Docker Container
  Part VIII: DockerCon Talk and The Story So Far