Riot Games

in deze eerste tutorial in de Docker serie, leert u:

• Wat we proberen te bereiken op Rellen

• Basic setup-instellingen voor de Docker

• Basic Docker Trek Opdrachten

• het uitvoeren van de Docker Containers Daemons

• Basic Jenkins configuratie opties

Toen ik voor het eerst begonnen met het leren over Docker een jaar geleden en het verkennen van zijn gebruik ik had problemen met het vinden van goede documentatie en voorbeelden – zelfs vandaag de dag veel beschrijven eenvoudige use cases die uiteindelijk niet klaar zijn voor productie. Het produceren van toepassingen met Docker containers vereist aanpassing aan hun kortstondige aard en single-process focus. Dit brengt uitdagingen met zich mee voor applicaties met data-persistentiebehoeften of multi-procesarchitecturen.

zoals ik al zei in mijn laatste bericht, gebruiken we Jenkins als een fundamenteel stuk open source software waarop we onze automatisering bouwen. Jenkins is ook een geweldige applicatie om een manier om na te denken over “Dockerizing” uw toepassingen te demonstreren. We zetten Jenkins in met deze architectonische componenten in het achterhoofd:

• Jenkins master server (Java proces)

• Jenkins stamgegevens (Plugins, Taakdefinities, enz.)

• nginx web proxy (we gebruiken SSL certs etc, met NGINX is een eenvoudige keuze hier)

• Slave agents bouwen (machines die SSH ‘ D in, of JNLP verbinden met, Jenkins Master)

Dit is een goede plek om te beginnen. Over deze serie van blog posts zal ik die manieren om na te denken over al het bovenstaande als containers en af te ronden met een geavanceerde blik op manieren om Docker containers te gebruiken als slaven bouwen. Om te beginnen maken we een Jenkins master server in een Docker container. Dan gaan we verder met het omgaan met gegevens persistentie en het toevoegen van een web proxy met NGINX.

deze hele blog serie zal betrekking hebben op de volgende Docker Concepten:

• het Maken van uw eigen Dockerfiles

• het Minimaliseren van het beeld afhankelijkheden op openbare afbeeldingen

• het Maken en gebruiken van Data-Volumes, met inbegrip van back-ups

• het Maken van containers “Omgevingen te Bouwen” met behulp van containers

• Handling “geheim” gegevens met beelden en Jenkins

Als u nog niet een kijkje genomen op de Cloudbees Jenkins Docker beeld, daar beginnen, want het is echt heel goed. Dit was mijn referentiepunt toen ik voor het eerst dacht aan het draaien van Jenkins in een Docker container en voor veel mensen zou dit voldoende zijn. Je kunt hun documentatie hier vinden en hun Git repo / Dockerfile hier.

dit eerste blog is opgesplitst in twee lesplannen. Elk is zo groot dat het ongeveer 30 minuten duurt om te voltooien. Ten eerste, deel een is het krijgen van uw ontwikkelomgeving klaar en leren om te werken met de standaard Jenkins Docker container die Cloudbees biedt. Deel twee gaat over het leggen van de basis om dit beeld in uw eigen Dockerfile te wikkelen en het nemen van meer elegante controle over het beeld. Samen zijn ze ontworpen om je op weg te helpen, vooral als je nog nooit eerder met Docker hebt gewerkt of relatief nieuw bent voor Docker—hoewel ze ervan uitgaan dat je al weet en begrijpt hoe je met Jenkins moet werken. Als je ervaring hebt met Docker, zal een deel van het materiaal in Les 1 Een beetje een herhaling zijn van dingen die je waarschijnlijk al weet.

les 1: Maak je eerste afbeelding

klaar om te beginnen. Hier bij Riot werken we met Docker (en Jenkins) op Windows, Mac OSX en Linux. Ik geef de voorkeur om te werken met Docker op OSX, hoewel het perfect functioneel is op Windows sinds Docker 1.6. Tegenwoordig zijn er uitstekende installateurs voor beide besturingssystemen. Ik zal werken vanuit een OSX perspectief, maar dezelfde tools bestaan voor Windows.

PRE-REQUIREMENTS:

1. U hebt Windows 10 Pro of Mac OSX Yosemite 10.10.3 (of hoger)

2 nodig. Als u Windows gebruikt, moet u ervoor zorgen dat Windows virtualisatie is ingeschakeld (zie de documentatie die Docker biedt)

een korte opmerking over KITEMATIC

met Docker 1.8 en de release van Docker Toolbox, Docker bevat nu “Kitematic,” een handige GUI tool om te helpen beheren en visualiseren wat er gebeurt met uw Docker afbeeldingen en containers. De meeste van deze tutorial richt zich op het gebruik van command-line argumenten en het werken met Docker zonder de Kitematic GUI. Dit is om je beter bloot te stellen aan de onderliggende mechanismen. Ook, in latere blogs begin ik met betrekking tot het gebruik van componeren om te beginnen en te stoppen met meerdere containers tegelijk.

STAP 1: INSTALLEER DOCKER

1. Ga naar: https://www.docker.com/docker-mac of https://www.docker.com/docker-windows

2. Download en installeer de juiste versie van Docker voor uw besturingssysteem

3. Volg alle installatieinstructies.

4. Controleer of uw installatie werkt door de aanbevolen shell voor uw besturingssysteem te openen (Terminal voor OSX, Powershell voor windows) door “Docker Quickstart Terminal”uit te voeren. Op Windows, dit zal een snelkoppeling op uw bureaublad. Op OSX, vindt u het in uw applications/Docker map. Controleer de volgende commando ‘ s en zorg ervoor dat u geen fouten krijgt

docker ps

docker info

5. Voordat we iets anders doen, moeten we het standaard geheugen en CPU-instellingen Docker gebruikt verhogen. Later gaan we Jenkins afstellen om meer geheugen te gebruiken en als we deze instellingen niet eerst aanpassen, kan Jenkins crashen.

• Ga naar uw Docker widget in uw werkbalk en selecteer “Voorkeuren”

• Ga naar het tabblad Geavanceerde configuratie

• verhoog CPU-gebruik tot ten minste 4 cores

6. Verhoog het geheugengebruik tot minstens 8 GB, bij voorkeur meer, ongeveer 12 GB om veilig te zijn (als je het beschikbaar hebt)

stap 2: PULL en voer de CloudBees JENKINS CONTAINER

1. Blijf in uw Docker terminal venster.

2. Haal Jenkins uit de publieke repo door het uitvoeren van:

docker pull jenkins/jenkins

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

3. Merk op dat het” Jenkins initial setup ” bericht in je shell venster een wachtwoord voor je zal genereren. Schrijf dat op als je het later nodig hebt. Als je het kwijtraakt, kun je `docker exec jenkins-master cat /var/jenkins_home/secrets/initialAdminPassword` uitvoeren met je container die draait om het op te halen.

4. Open uw favoriete browser en wijs het aan http://localhost:8080

let op, je zult zien dat ik gebruik maken van de Docker — naam vlag en de naam van de container jenkins-master – Dit is een conventie die Ik zal gebruiken in deze blog. Het benoemen van uw containers is een handige best practice met drie voordelen:

1. Het maakt ze gemakkelijk te onthouden en interactie met

2. Docker staat niet toe dat twee containers dezelfde naam hebben, wat fouten voorkomt zoals het per ongeluk starten van twee identieke containers

3. Veel voorkomende Docker tools (zoals Docker Compose) gebruiken specifieke container namen, dus wennen aan het benoemen van uw containers is een goede Best practice.

stap 3: dit iets praktischer maken

de vorige stap start Jenkins met zijn meest basale Opstartinstellingen. Je kunt zelfs zien dat Jenkins basic config nodig heeft en je vraagt om een Administrator wachtwoord (dat je kunt krijgen van de logs die op je scherm getoond worden tijdens het opstarten). Als je net als Riot bent, is het onwaarschijnlijk dat je Jenkins op Standaardinstellingen draait. Laten we lopen door het toevoegen van een aantal nuttige opties. We zullen Jenkins nog niet configureren; het is genoeg om te weten dat het kan starten en draaien.

stap 3A: DAEMONIZING

u wilt waarschijnlijk niet dat Jenkins logs meestal naar standaard worden uitgespuwd. Gebruik dus de vlag Docker daemon om de container (-d) te starten.

1. Ctrl-c op het terminalvenster waarop uw container wordt uitgevoerd om deze te stoppen

2. Voer de volgende commando ‘ s uit

docker rm jenkins-master

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

nu moet je gewoon een hash string weergegeven en worden teruggestuurd naar uw terminal. Als je nieuw bent bij Docker, is die hash string eigenlijk de unieke ID van je container (handig als je begint met het automatiseren van deze commando ‘ s).

stap 3B: geheugeninstellingen

we hebben de neiging om Jenkins te draaien met enkele vlezige instellingen bij Riot. Weet je nog toen je de CPU/geheugen Docker eerder gebruikt verhoogd? Dit is de belangrijkste reden waarom. Voer voor een eenvoudige start de volgende commando ‘ s uit

docker stop jenkins-master

docker rm jenkins-master

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

dat zou Jenkins een mooie 8 GB geheugen pool moeten geven en ruimte om vuilnis te verzamelen.

stap 3C: het verhogen van de verbindingspool

tijdens Riot, krijgen we veel verkeer naar onze Jenkins server, dus we hebben geleerd om Jenkins wat meer ademruimte te geven. Voer het volgende uit

docker stop jenkins-master

docker rm jenkins-master

dat geeft Jenkins een mooie basis van begeleiders en een pet. Toevallig heb je nu geleerd hoe je zowel JAVA OPTS als JENKINS OPTS als omgevingsvariabelen op een zinvolle manier kunt gebruiken. Let op, dit werkt vanwege hoe Cloudbees gemakkelijk gestructureerd hun Jenkins Dockerfile.

stap 4: alles samenvoegen

ik heb alles wat we hier geleerd hebben in een eenvoudige makefile geplaatst, zodat je make commando ‘ s kunt gebruiken om je Jenkins docker container te besturen. U vindt het hier:

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

u kunt de volgende commando ‘ s gebruiken:

• make build-trekt de Jenkins afbeelding

• maak run-loopt de container

• stop maken-stopt de container

• maak schoon-stopt en verwijdert de bestaande container

je hoeft de makefile niet te gebruiken, Ik vind het gewoon makkelijker dan het hele run commando uit te typen. U kunt deze gemakkelijk in een script van uw keuze plaats.

hopelijk zie je hoe makkelijk het is om aan de slag te gaan met Docker en Jenkins. Ik heb geprobeerd om u een aantal basisopties te geven om de standaard Cloudbees Jenkins container te nemen en het een beetje meer bruikbaar te maken. Cloudbees heeft veel handige tutorials voor het uitvoeren van hun container, zoals het vooraf installeren van plugins en het opslaan van Jenkins gegevens.

dat brengt mij bij de toekomstige posten over dit onderwerp. Deze container / image is nuttig maar heeft een paar nadelen: geen consistente logging, geen doorzettingsvermogen, geen webserver proxy ervoor, en geen schone manier om te garanderen dat je de versie van Jenkins gebruikt die je wilt. Dit roept vragen op als: wat als je wilt vasthouden aan een oudere versie? Of wat als u de laatste beschikbare release periode wilt gebruiken?

in de volgende les zal ik ingaan op het maken van deze container een beetje robuuster. Vooral:

• het Maken van uw eigen Dockerfile om wrap de Cloudbees base

• het Verplaatsen van de omgevingsvariabelen in deze nieuwe afbeelding

• het Maken van een logboek, het instellen van machtigingen en andere nuttige Jenkins mappen, en het ophalen van de Jenkins logs terwijl het draait

LES 2 – EEN JENKINS BASE IMAGE-WRAPPER

In de vorige les heb ik besproken opzetten van een ontwikkelomgeving voor het uitvoeren van de Docker en experimenteerde met de Jenkins Docker beeld van Cloudbees. We vonden dat het eenvoudig en makkelijk te gebruiken was, met een aantal geweldige functies uit de doos. Om vooruitgang te boeken in de verbetering van de gebieden die we geïdentificeerd, in het Koppelvenster concepten in deze les zijn:

• het Maken van uw eigen Dockerfile

• het Instellen van omgevingsvariabelen in een Dockerfile

• mappen Maken en machtigingen in een Dockerfile

• met Behulp van de docker exec om opdrachten uit te voeren tegen een actieve container

het MAKEN van UW BASE DOCKERFILE

willen We enkele wijzigingen aan hoe Jenkins begint standaard. In de laatste blog hebben we dit afgehandeld door een makefile te maken die in argumenten werd doorgegeven als omgevingsvariabelen. Gegeven dat we dit elke keer willen doen, kunnen we die gewoon verplaatsen naar onze eigen Dockerfile. Bovendien laat onze eigen Dockerfile ons de versie van Jenkins vergrendelen die we gebruiken voor het geval Cloudbees hun versie bijwerkt en we niet klaar zijn om te upgraden.

we doen dit in vier stappen:

1. Maak een werkmap

2. Maak in uw favoriete teksteditor een nieuw bestand aan met de naam “Dockerfile”

3. Voeg het volgende toe aan het bestand en sla het op:

FROM jenkins/jenkins:2.112LABEL maintainer=""

4. Voer vervolgens op de opdrachtregel:

docker build -t myjenkins .

wat we hier deden was een bepaalde versie van het Jenkins beeld uit de public docker repo halen. Alle beschikbare versies vindt u hier:

• u kunt altijd de FROM-clausule instellen op welke versie van de afbeelding beschikbaar is. Echter, je kunt de versie niet gewoon instellen op welke versie van Jenkins je wilt. Dit is de image versie “tag” of “label,” en Cloudbees is mooi genoeg om het te laten overeenkomen met de Jenkins versie in de image. Cloudbees biedt “jenkins/jenkins” aan als een handige manier om de nieuwste versie te krijgen, of “jenkins/jenkins:lts” om de meest recente “Long Term Support” versie te krijgen. In dit voorbeeld gebruik ik een specifieke versie. Deze tags die label soorten releases zijn geweldig, maar het gebruik ervan betekent dat de versie van Jenkins onder je kan veranderen, wat complicaties kan veroorzaken als je niet klaar bent om te upgraden. Ik beveel “versie vergrendelen” als een algemene beste praktijk bij het omgaan met afhankelijkheden in Docker of andere afhankelijkheid management tools. Je wilt dat dingen veranderen als je dat van plan bent, niet eerder. Daarom gebruik ik hier een specifieke versie.

  het nieuwe DOCKERFILE

  testen we kunnen heel eenvoudig overschakelen naar de image door ons docker run commando als volgt aan te passen:

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

  nu kunnen we deze omgevingsvariabelen opschonen door ze in onze eigen Dockerfile te plaatsen.

  omgevingsvariabelen toevoegen aan onze DOCKERFILE

  het is eenvoudig om standaardinstellingen toe te voegen voor dingen als omgevingsvariabelen aan Dockerfiles. Dit levert ook een mooi stukje zelfdocumentatie op. En, omdat je deze altijd kunt overschrijven bij het uitvoeren van de Docker container, er is echt geen nadeel.

  1. Voeg in uw Dockerfile de volgende regels toe na de” MAINTAINER ” regel:

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

  2. Uw Afbeelding opslaan en opnieuw opbouwen:

  • docker build-t myjenkins .

  docker build -t myjenkins .

  vrij eenvoudig! U kunt testen dat het nog steeds werkt door het invoeren van de volgende drie commando ‘ s:

  docker stop jenkins-master

  docker rm jenkins-master

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

  

  je imago moet meteen beginnen! Maar hoe weet je dat de omgevingsvariabelen werkten? Eenvoudig: op dezelfde manier dat je zou controleren om te zien welke argumenten je Jenkins app normaal gestart met ps. En dit werkt zelfs als je je ontwikkelt op Windows.

  het uitvoeren van een basis commando tegen uw CONTAINER

  om te bevestigen dat de Java en Jenkins opties correct zijn ingesteld, kunnen we ps draaien in onze container en het uitvoeren van Jenkins Java proces zien door docker exec

  docker exec jenkins-master ps -ef | grep java

  te gebruiken.

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

  

  vanaf deze, kunt u gemakkelijk zien onze instellingen zijn vastgelopen. docker exec is een eenvoudige manier om shell commando ‘ s uit te voeren in uw container en ook een ongelooflijk eenvoudige manier om ze te inspecteren. Dit werkt zelfs op Windows omdat, vergeet niet, het commando na “exec” wordt uitgevoerd in uw container en dus is gebaseerd op welke basis afbeelding uw container gebruikt.

  het opzetten van een LOG map

  in de vorige blog merkten we op dat we het zicht verloren in de Jenkins logs toen we onze container draaiden met de daemonize vlag (-d). We willen de ingebouwde Jenkins functie gebruiken om een log map in te stellen. We moeten dit in onze Dockerfile doen en dan de logoptie doorgeven aan Jenkins.

  laten we onze Dockerfile opnieuw bewerken. Tussen de “MAINTAINER” en de eerste ENV regel gaan we het volgende

  RUN mkdir /var/log/jenkins

  toevoegen we plaatsen het commando op deze locatie in het bestand om de beste praktijken te volgen. Het is waarschijnlijker dat we de omgevingsvariabelen zullen veranderen dan deze installatiemappen, en elke opdrachtregel in een Dockerfile wordt in wezen zijn eigen afbeeldingslaag. U maximaliseert het hergebruik van de laag door regelmatig gewijzigde items aan de onderkant te plaatsen.

  Maak nu opnieuw je afbeelding:

  docker build -t myjenkins

  u krijgt een fout die lijkt op

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

  

  geen zorgen. Dit komt omdat de standaard Cloudbees container de draaiende gebruiker instelt op de” Jenkins ” gebruiker. Als je naar hun Dockerfile kijkt (hier te vinden: https://github.com/ Jenkinsci/docker/blob/master / Dockerfile) zie je, onderaan

  USER ${user}

  deze syntaxis kan een beetje verwarrend zijn. Het maakt gebruik van Docker ’s build” argumenten ” om u in staat om de gebruiker te definiëren. Als u verder het Docker-bestand zoekt, vindt u de standaardwaarde. Kijk in de buurt van de bovenkant van het Dockerfile voor

  ARG user=jenkins

  dit creëert het “user” argument (ARG) en stelt het in op de Jenkins gebruiker. Dit staat je toe om de Gebruikersnaam te veranderen die Jenkins gebruikt wanneer je docker build –build-arg somevariable=somevalue aanroept. Merk op dat dit alleen werkt als je het Dockerfile vanaf nul bouwt. U kunt deze waarden niet wijzigen met een Docker pull of een docker run. U kunt hier meer lezen over bouwargumenten. Omdat we een voorgebouwde versie gebruiken in onze FROM clausule, eindigen we met de standaard gebruiker: “jenkins”.

  in normale Linux zou je SUDO of een andere manier gebruiken om de map aan te maken (/var/log is eigendom van root). Gelukkig voor ons Docker laat ons schakelen gebruikers.

  voeg het volgende toe aan uw Dockerfile:

  1. Voordat uw mkdir-regel wordt uitgevoerd, toevoegen

  USER root

  2. Na uw RUN mkdir lijn toevoegen

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

  3. Na uw Run chown lijn toevoegen:

  USER jenkins

  merk op dat we ook een chown Commando moesten toevoegen omdat we willen dat de Jenkins gebruiker naar de map kan schrijven. Vervolgens zetten we Root en resetten Jenkins zodat het gedrag van de Dockerfile behouden blijft.

  Maak nu opnieuw je afbeelding:

  docker build -t myjenkins .

  

  en… je fouten zouden weg moeten zijn.

  met de log directory set (let op: je kunt deze map plaatsen waar je wilt, we gebruiken /var/log voor consistentie) kunnen we Jenkins nu vertellen om naar die map te schrijven bij het opstarten door de JENKINS_OPTS omgevingsvariabelen aan te passen.

  in uw Dockerfile bewerk de JENKINS_OPTS regel om er zo uit te zien:

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

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

  bouw nu nog een keer je afbeelding

  docker build -t myjenkins .

  laten we onze nieuwe afbeelding testen en of we het logbestand kunnen volgen! Probeer de volgende commando ‘ s

  docker stop jenkins-master

  docker rm jenkins-master

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

  met de container draaiend kunnen we het logbestand volgen als alles werkte

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

  haal LOGS op als JENKINS crasht

  tijd voor een bonusronde! Zolang we het over Logboeken hebben, is Docker een interessant probleem als Jenkins crasht. De container zal stoppen met draaien en docker exec zal niet meer werken. Dus wat te doen?

  we zullen later meer geavanceerde manieren bespreken om het logbestand aan te houden. Voor nu, omdat de container is gestopt kunnen we Bestanden kopiëren uit het met behulp van de Docker CP Commando. Laten we een crash simuleren door de container te stoppen, en dan de logs ophalen:

  1. ctrl-c om de staart van het logbestand

  te verlaten 2. Voer de volgende commando ‘ s uit

  docker stop jenkins-master

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

  cat jenkins.log

  

  afsluitende gedachten

  je kunt al het werk in mijn tutorial Git repo (en de bijgewerkte convenience makefile) hier vinden:

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

  door onze eigen Dockerfile te maken die het Cloudbees-bestand omhult, konden we het leven een beetje makkelijker maken voor onszelf. We het opzetten van een handige plek om de logs op te slaan en geleerd hoe om te kijken naar hen met de Docker exec Commando. We hebben onze standaardinstellingen verplaatst naar de Dockerfile en nu kunnen we dit opslaan in Broncontrole als een goed stuk zelfdocumentatie.

  we hebben nog steeds een data persistence challenge. We hebben geleerd hoe je logbestanden uit een gestopt container kunt halen (handig als Jenkins crasht). Maar in het algemeen als onze container stopt, verliezen we nog steeds alle banen die we gecreëerd hebben. Zonder doorzettingsvermogen is dit Jenkins image dus alleen nuttig voor lokale ontwikkeling en testen.

  dat leidt ons naar het volgende artikel. Met onze fundamenten op hun plaats-onze eigen Dockerfile wrapper, vergrendeld op een handige versie van Jenkins-kunnen we het persistentieprobleem oplossen. Het volgende artikel zal deze concepten verkennen:

  • het Behoud van Jenkins Baan en Plugin

  • Docker Data Persistentie met Volumes

  • het Maken van een Data-Volume container

  • het Delen van gegevens in de volumes met andere containers

  Voor meer informatie, bekijk de rest van deze serie:

  Deel I: het Denken In de Container
  Deel II: het plaatsen van Jenkins in een Docker Container (dit artikel)
  Deel III: Docker & Jenkins: Gegevens Die Aanhoudt
  Deel IV: Jenkins, Dokwerker, Proxy ‘ s en Componeren
  Deel V: Beheer van uw Docker-Image
  Deel VI: bouwen met Jenkins in een kortstondige Docker-Container
  Deel VII: handleiding: bouwen met Jenkins in een kortstondig Docker-Container
  deel VIII: DockerCon Talk en het verhaal tot nu toe