Enkel Jenkins-rørledning med Marathon og Mesos

1. Introduksjon

I denne artikkelen skal vi implementere en enkel rørledning for kontinuerlig levering med Jenkins, Marathon og Mesos.

Først vil vi gi en oversikt på høyt nivå av teknologibakken og arkitekturen, med en forklaring på hvordan alt passer sammen. Etter det vil vi gå videre til et praktisk, trinnvis eksempel.

Resultatet av dette vil være en helautomatisk Jenkins-rørledning som distribuerer applikasjonen vår til Mesos-klyngen ved hjelp av Marathon.

2. Oversikt over Technology Stack

Når vi jobber med containere og mikrotjenestearkitekturer, står vi overfor nye driftsproblemer som vi ikke hadde gjort med mer tradisjonelle stabler.

For eksempel når vi distribuerer til en klynge, må vi håndtere skalering, failover, nettverk og mer. Disse vanskelige, distribuerte databehandlingsproblemene, kan løses med distribuerte kjerner og planleggere, som Apache Mesos og Marathon.

2.1. Mesos

Mesos, i de enkleste termer, kan sees på som den eneste serveren hvor applikasjonene våre skal kjøres. I virkeligheten har vi en klynge, men det er denne abstraksjonen som gjør den så nyttig.

2.2. Maraton

Marathon er rammeverket som brukes til å distribuere applikasjonene våre til Mesos, og løse vanskelige problemer for oss (helsekontroll, automatisk skalering, failover, overvåking osv.).

3. Oppsett og installasjon

Denne artikkelen antar at du allerede har Jenkins, Mesos og Marathon. Hvis dette ikke er tilfelle, kan du lese den offisielle dokumentasjonen for hver av dem for å lære hvordan du konfigurerer dem. Uten dette vil du ikke kunne implementere noen av trinnene i guiden.

4. Vår leveringsrørledning

Vi skal lage følgende Jenkins-rørledning:

Det er ikke noe spesielt komplisert med denne tilnærmingen - den er synonymt med strømmen til de fleste moderne CD-rørledninger. I vårt tilfelle vil bygging bety at containerisering av applikasjonen, og distribusjon vil bety at du bruker Marathon for å planlegge den på en Mesos-klynge.

5. Testing og bygging av applikasjonen vår

Det første trinnet er å bygge og teste applikasjonen vår. For å holde ting enkelt, er applikasjonen vi skal jobbe med en Spring Boot-applikasjon. På grunn av dette vil vår resulterende gjenstand være en kjørbar krukke. Det vil ikke ha andre eksterne avhengigheter enn JRE, noe som gjør det veldig enkelt å utføre.

5.1. Å skape vår jobb

Det første vi vil gjøre er å opprette Jenkins-jobben vår. La oss velge "Nytt element" i navigasjonslinjen til venstre, og deretter velge opprett et freestyle-prosjekt, og gi det navnet "maraton-mesos-demo:

5.2. Integrering med Git

La oss deretter konfigurere den til å klone Github-databasen som inneholder applikasjonen vår:

For enkelhets skyld er depotet vårt offentlig, noe som betyr at vi klarer å klone over https. Hvis dette ikke var tilfelle og vi klonet over SSH, ville det være et ekstra trinn for å sette opp en SSH-bruker og privat nøkkel, utenfor omfanget av denne artikkelen.

5.3. Sette opp Build Triggers

Deretter la oss sette opp noen build-utløsere, slik at jobben vår vil avstemme git for nye forpliktelser hvert minutt:

5.4. Genererer Build-skriptet vårt

Vi kan nå fortelle jobben vår å utføre et skallskript når det kjører. Når vi jobber med et enkelt Spring Boot Maven-prosjekt, er alt vi trenger å gjøre, å kjøre kommandoen “mvn ren installasjon“. Dette vil kjøre alle testene og bygge vår kjørbare krukke:

5.5. Bygg prosjektet vårt

Nå har vi satt opp begynnelsen på rørledningen, la oss utløse den manuelt ved å klikke "Bygg nå" på jobben. Når jobben er ferdig, kan vi bekrefte at den har bestått ved at den er merket som blå.

6. Containerizing vår søknad

La oss gå videre til neste trinn i rørledningen vår, som er pakking og publisering av applikasjonen vår med Docker. Vi må bruke Docker som containere er spesifikt det Marathon klarer. Dette er ikke urimelig, da nesten alt kan kjøre i en container. Det er lettere for et verktøy som Marathon å jobbe med abstraksjonen gitt av disse.

6.1. Opprette Dockerfile

La oss først lage en Dockerfile i prosjektroten. I hovedsak er en Dockerfile en fil som inneholder instruksjoner til Docker Deamon om hvordan du bygger et bilde:

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

Bildet vi bygger er enkelt - alt det inneholder er en kjørbar krukke og en skallkommando som vil utføre den når beholderen starter. Vi må også sørge for at vi eksponerer porten som applikasjonen vår vil lytte til, i dette tilfellet ‘8082’.

6.2. Publisering av bildet

Nå som vi kan bygge bildet vårt, la oss lage et enkelt bash-skript som bygger og publiserer det til vårt private Docker Hub-lager, og legger det i vår prosjektrot:

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

Du må kanskje skyve bildet ditt til det offentlige dockerregisteret eller din private.

De $ BUILD_NUMBER miljøvariabelen er fylt av Jenkins, og øker med hver bygning. Selv om det er litt sprøtt, er det en rask måte å få hvert bygg til å øke i versjonsnummer. De $ DOCKER_PASSWORD er også befolket av Jenkins, og i dette tilfellet vil vi bruke EnvInject-plugin for å holde det hemmelig.

Mens vi kunne lagre dette skriptet direkte i Jenkins, er det bedre praksis at det forblir i versjonskontroll, da det deretter kan versjoneres og revideres sammen med resten av prosjektet vårt.

6.3. Bygge og publisere på Jenkins

La oss nå endre Jenkins-jobben vår slik at den kjører "Dockerise.sh" etter at krukken er bygd:

Og så, la oss kjøre jobben vår for å bekrefte igjen, og bekrefte at alt fungerer ved at det går blått.

7. Implementere vårt bilde

Rørledningen vår er nesten fullført. Det er bare ett trinn til, det er å bruke Marathon til å distribuere applikasjonen vår til Mesos-klyngen.

Jenkins kommer med en "Deploy with Marathon" -tillegg. Dette fungerer som en omslag rundt Marathon API, noe som gjør det lettere enn det ville være når du jobber med tradisjonell skallskripting. Du kan installere det via plugin manager.

7.1. Opprette Marathon.Json File

Før vi kan bruke Marathon-pluginet, må vi lage en "marathon.json" -fil, og lagre den i prosjektroten. Dette er fordi pluginet er avhengig av det.

Denne filen: “marathon.json” inneholder en Mesos Application Definition. Dette er en beskrivelse av en langvarig tjeneste (applikasjon) som vi ønsker å kjøre. Til slutt vil Jenkins Marathon-plugin POST innholdet av filen til Marathon / v2 / apper endepunkt. Marathon vil deretter i sin tur planlegge den definerte applikasjonen for å kjøre på Mesos:

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

Dette er den enkleste konfigurasjonen vi kan gi for en containerisert applikasjon.

Eiendommen: "portMappings”Må settes riktig for å gjøre søknaden vår tilgjengelig fra vår Mesos-slave. Det betyr i utgangspunktet, kart containerporten 8082, til en tilfeldig port på verten (mesos slave) slik at vi kan snakke med søknaden vår fra omverdenen. Etter å ha distribuert applikasjonen vår, vil Marathon fortelle oss hva den porten brukte.

7.2. Legge til et Marathon Deployment Build Step

La oss legge til en Marathon Deployment post build-handling i jobben vår:

Legg merke til at vi forteller pluginet hvor Marathon løper, i dette tilfellet 'localhost: 8081'. Vi forteller det også bildet vi vil distribuere. Dette er hva det tomme "bilde" -feltet i filen blir erstattet med.

Nå har vi opprettet den siste fasen av rørledningen vår, la oss kjøre jobben vår en gang til og bekrefte at den fortsatt går, denne gangen med det ekstra trinnet der det sender søknaden vår til Marathon.

7.3. Verifisere vår implementering i maraton

Nå er den distribuert, la oss ta en titt i Marathon UI:

Som vi kan se, vises applikasjonen vår nå i brukergrensesnittet. For å få tilgang til det, trenger vi bare å sjekke hvilken vert og port det er tildelt:

I dette tilfellet er porten 31143 tilfeldig tildelt på localhost, som internt tilordnes port 8082 i containeren vår som konfigurert i applikasjonsdefinisjonen. Vi kan deretter besøke denne URL-en i nettleseren vår for å bekrefte at applikasjonen blir servert riktig.

8. Konklusjon

I denne artikkelen har vi laget en enkel rørledning for kontinuerlig levering ved hjelp av Jenkins, Marathon og Mesos. Hver gang vi presser en endring i koden vår, vil den kjøre i et miljø noen minutter senere.

Senere artikler i denne serien vil dekke mer avanserte Marathon-emner, for eksempel applikasjonens helsekontroll, skalering, failover. Andre brukssaker for Mesos, som for eksempel batchbehandling, kan også dekkes.

Kildekoden for applikasjonen vår er tilgjengelig på GitHub; dette er et Maven-prosjekt som skal kunne kjøre som det er.


$config[zx-auto] not found$config[zx-overlay] not found