Dockerisatie van Java-apps met Jib

1. Overzicht

In deze tutorial bekijken we Jib en hoe het de containerisatie van Java-applicaties vereenvoudigt.

We nemen een eenvoudige Spring Boot-applicatie en bouwen de Docker-image met Jib. En dan publiceren we de afbeelding ook naar een register op afstand.

En vergeet niet om ook onze tutorial te raadplegen over het koppelen van Spring Boot-applicaties met dockerfile en doker gereedschap.

2. Inleiding tot Jib

Fok is een open-source Java-tool die wordt onderhouden door Google voor het bouwen van Docker-images van Java-applicaties. Het vereenvoudigt de containerisatie, omdat daarmee we hoeven geen dockerfile.

En eigenlijk, we hoeven niet eens te hebben havenarbeider geïnstalleerd om de docker-afbeeldingen zelf te maken en te publiceren.

Google publiceert Jib als zowel een Maven- als een Gradle-plug-in. Dit is prettig omdat het betekent dat Jib elke wijziging die we in onze applicatie aanbrengen elke keer dat we bouwen zal opvangen. Dit bespaart ons aparte docker build / push-opdrachten en vereenvoudigt het toevoegen van deze aan een CI-pijplijn.

Er zijn ook een aantal andere tools beschikbaar, zoals Spotify's docker-maven-plug-in en dockerfile-maven-plug-ins, hoewel de eerste nu verouderd is en de laatste een dockerfile.

3. Een eenvoudige groet-app

Laten we een eenvoudige spring-boot-applicatie nemen en deze dockeriseren met Jib. Het zal een eenvoudig GET-eindpunt blootleggen:

// localhost: 8080 / groet

Wat we heel eenvoudig kunnen doen met een Spring MVC-controller:

@RestController openbare klasse GreetingController {privé statische laatste String-sjabloon = "Hallo Docker,% s!"; privé finale AtomicLong-teller = nieuwe AtomicLong (); @GetMapping ("/ groet") openbare begroeting (@RequestParam (waarde = "naam", defaultValue = "Wereld") Tekenreeksnaam) {retourneer nieuwe begroeting (counter.incrementAndGet (), String.format (sjabloon, naam)) ; }} 

4. De implementatie voorbereiden

We zullen ons ook lokaal moeten instellen om te verifiëren met de Docker-repository waarnaar we willen implementeren.

Voor dit voorbeeld zullen we verstrek onze DockerHub-inloggegevens aan .m2 / settings.xml:

  registry.hub.docker.com 

Er zijn ook andere manieren om de inloggegevens op te geven. De aanbevolen manier van Google is om helper-tools te gebruiken, die de inloggegevens in een gecodeerde indeling in het bestandssysteem kunnen opslaan. In dit voorbeeld hadden we docker-credential-helpers kunnen gebruiken in plaats van inloggegevens voor platte tekst op te slaan in settings.xml, wat veel veiliger is, maar gewoon buiten het bereik van deze tutorial valt.

5. Implementeren naar Docker Hub met Jib

Nu kunnen we gebruiken jib-maven-plugin, of het Gradle-equivalent, naarcontainerize onze applicatie met een eenvoudig commando:

mvn compileren com.google.cloud.tools:jib-maven-plugin:2.5.0:build -Dimage = $ IMAGE_PATH

waarbij IMAGE_PATH het doelpad in het containerregister is.

Bijvoorbeeld om de afbeelding te uploaden baeldungjib / spring-jib-app naar DockerHub, zouden we doen:

exporteer IMAGE_PATH = registry.hub.docker.com / baeldungjib / spring-jib-app

En dat is het! Hiermee wordt de docker-afbeelding van onze applicatie gebouwd en naar het DockerHub.

We kunnen natuurlijkupload de afbeelding op een vergelijkbare manier naar Google Container Registry of Amazon Elastic Container Registry.

6. Vereenvoudiging van het Maven-commando

We kunnen ook onze eerste opdracht verkorten door de plug-in in onze pom in plaats daarvan, net als elke andere maven-plug-in.

 ... ... com.google.cloud.tools jib-maven-plugin 2.5.0 $ {image.path} ... ... 

Met deze wijziging kunnen we ons maven-commando vereenvoudigen:

mvn compileren jib: build

7. Docker-aspecten aanpassen

Standaard, Jib doet een aantal redelijke inschattingen over wat we willen, zoals de FROM en het ENTRYPOINT.

Laten we een paar wijzigingen aanbrengen in onze applicatie die specifieker zijn voor onze behoeften.

Ten eerste stelt Spring Boot standaard poort 8080 bloot.

Maar laten we zeggen dat we onze applicatie op poort 8082 willen laten draaien en deze via een container zichtbaar willen maken.

Natuurlijk zullen we de juiste wijzigingen aanbrengen in Boot. En daarna kunnen we Jib gebruiken om het zichtbaar te maken in de afbeelding:

 ...   8082   

Of, laten we zeggen dat we een andere FROM nodig hebben. Standaard gebruikt Jib de distro-loze java-afbeelding.

Als we onze applicatie op een andere basisimage willen draaien, zoals alpine-java, kunnen we deze op een vergelijkbare manier configureren:

 ... openjdk: alpine ... 

We configureren tags, volumes en verschillende andere Docker-richtlijnen op dezelfde manier.

8. Java-aspecten aanpassen

En door associatie ondersteunt Jib ook tal van Java-runtime-configuraties:

  • jvmFlags is om aan te geven welke opstartvlaggen aan de JVM moeten worden doorgegeven.
  • mainClass is voor het aangeven van de hoofdklasse, die Jib zal standaard automatisch proberen af ​​te leiden.
  • args is waar we de programma-argumenten specificeren die zijn doorgegeven aan de hoofd methode.

Bekijk natuurlijk de documentatie van Jib om alle beschikbare configuratie-eigenschappen te zien.

9. Conclusie

In deze zelfstudie hebben we gezien hoe u docker-images kunt bouwen en publiceren met Google's Jib, inclusief hoe u toegang krijgt tot de docker-instructies en Java-runtime-configuraties via Maven.

Zoals altijd is de broncode voor dit voorbeeld beschikbaar op Github.