TOC

Dockérisation des applications Java à l’aide de Jib

Dans ce didacticiel, nous examinerons Jib et comment cela simplifie la conteneurisation des applications Java.

Nous allons prendre une simple application Spring Boot et construire son image Docker à l’aide de Jib. Et ensuite, nous publierons également l’image sur un registre distant.

Et assurez-vous également de vous reporter à notre tutoriel sur la dockerisation Spring Applications de démarrage utilisant dockerfile et d _ocker _ tool .

Jib est un outil Java à code source ouvert mis à jour par Google pour la création d’images Docker d’applications Java. Cela simplifie la conteneurisation car avec elle, nous n’avons pas besoin d’écrire un dockerfile .

Et en réalité, il n’est même pas nécessaire que docker soit installé pour créer et publier les images du menu fixe nous-mêmes.

Google publie Jib en tant que plugin Maven et Gradle. C’est bien parce que cela signifie que Jib détectera tous les changements que nous apportons à notre application chaque fois que nous construisons. Cela nous évite des commandes distinctes de construction/transmission du docker et simplifie l’ajout de cela à un pipeline CI.

Il existe également quelques autres outils, tels que docker-maven-plugin et https://github.com/spotify/dockerfile-maven de Spotify plugins[dockerfile-maven], bien que le premier soit maintenant obsolète et que le dernier nécessite un dockerfile .

Prenons une simple application de type spring-boot et dockerize à l’aide de Jib.

Il exposera un point d’extrémité GET simple: 

http://localhost:8080/greeting

Ce que nous pouvons faire très simplement avec un contrôleur Spring MVC: 

@RestController
public class GreetingController {

    private static final String template = "Hello Docker, %s!";
    private final AtomicLong counter = new AtomicLong();

    @GetMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name",
        defaultValue="World") String name) {

        return new Greeting(counter.incrementAndGet(),
          String.format(template, name));
    }
}

Nous devrons également nous configurer localement pour nous authentifier auprès du référentiel Docker dans lequel nous souhaitons déployer.

Pour cet exemple, nous fournirons nos informations d’identification DockerHub à .m2/settings.xml : 

<servers>
    <server>
        <id>registry.hub.docker.com</id>
        <username><DockerHub Username></username>
        <password><DockerHub Password></password>
    </server>
</servers>

Il existe également d’autres moyens de fournir les informations d’identification. ** La méthode recommandée par Google consiste à utiliser des outils auxiliaires, qui permettent de stocker les informations d’identification dans un format crypté dans le système de fichiers. Dans cet exemple, nous aurions pu utiliser https://github.com/docker/docker-credential-helpers#available-programs plus sûr, mais tout simplement hors de portée pour ce tutoriel.

Nous pouvons maintenant utiliser jib-maven-plugin ou l’équivalent Gradle , à conteneuriser notre application avec une simple commande : 

mvn compile com.google.cloud.tools:jib-maven-plugin:0.9.10:build -Dimage=$IMAGE__PATH

où IMAGE__PATH est le chemin cible dans le registre de conteneurs.

Par exemple, pour télécharger l’image baeldungjib/spring-jib-app vers DockerHub , nous ferions: 

export IMAGE__PATH=registry.hub.docker.com/baeldungjib/spring-jib-app

Et c’est tout! Cela construira l’image de menu fixe de notre application et la poussera vers le DockerHub .

/uploads/JibDocker-1-1024x640-100x63.jpg%20100w

6. Simplifier la commande Maven

De plus, nous pouvons raccourcir notre commande initiale en configurant le plugin dans notre pom à la place, comme n’importe quel autre plugin maven. 

<project>
    ...
    <build>
        <plugins>
            ...
            <plugin>
                <groupId>com.google.cloud.tools</groupId>
                <artifactId>jib-maven-plugin</artifactId>
                <version>0.9.10</version>
                <configuration>
                    <to>
                        <image>${image.path}</image>
                    </to>
                </configuration>
            </plugin>
            ...
        </plugins>
    </build>
    ...
</project>

Avec ce changement, nous pouvons simplifier notre commande maven: 

mvn compile jib:build



















Par défaut,

Jib émet un certain nombre de suppositions raisonnables sur ce que nous voulons

, comme le FROM et le ENTRYPOINT.








Apportons quelques modifications à notre application qui sont plus spécifiques à nos besoins.








Tout d’abord, Spring Boot expose le port 8080 par défaut.








Mais, disons, nous voulons que notre application soit exécutée sur le port 8082 et qu’elle soit accessible via un conteneur.








Bien entendu, nous apporterons les modifications appropriées dans Boot. Et, après cela, nous pouvons utiliser Jib pour le rendre visible dans l’image:









<configuration>
    ...
    <container>
        <ports>
            <port>8082</port>
        </ports>
    </container>
</configuration>









Ou bien, disons qu’il nous faut un autre FROM.

Par défaut, Jib utilise l’image

distro-less


.








Si nous voulons exécuter notre application sur une image de base différente, telle que

alpine-java

, nous pouvons le configurer de la même manière:









<configuration>
    ...
    <from>
        <image>openjdk:alpine</image>
    </from>
    ...
</configuration>









Nous configurons les balises, les volumes et

several autres directives Docker

de la même manière.











8. Personnalisation des aspects Java







Et, par association, Jib prend également en charge de nombreuses configurations d’exécution Java:







    

  • 

    


_jvmFlags

_

est utilisé pour indiquer les indicateurs de démarrage à transmettre à la machine virtuelle Java.

    

    • 

  • 

    

__mainClass

__is pour indiquer la classe principale, que ** Jib sera

    

    • 








tenter de déduire automatiquement par défaut.



args

est où nous spécifions les arguments du programme passés à








la


_ principale

_

méthode.








Bien sûr, assurez-vous de consulter la documentation de Jib pour voir toutes les propriétés de configuration

https://github.com/GoogleContainerTools/jib/tree/master/jib-maven-plugin

]].


















Dans ce didacticiel, nous avons vu comment créer et publier des images de menu fixe à l’aide de la Jib de Google, et notamment comment accéder aux directives du menu fixe et aux configurations d’exécution Java via Maven.








Comme toujours, le code source de cet exemple est disponible

over sur Github

.




























































Related