25 septembre 2018 | DevOps | Kevin Davin

Jib - Construire mon image docker sans docker

Temps de lecture estimé : 3 minutes

Et si on simplifiait la création de container Docker dans la phase de développement ?

Vous en avez assez de lancer la commande docker, on va voir comment s’en passer dans votre travail quotidien en utilisant Jib.

On va partir d’une simple application Spring Boot et configurer Maven pour vous permettre de construire une image compatible Docker (et cela sans Docker !)

Afin de contruire une application rapidement, on va partir de https://start.spring.io/ et générer un projet web standard :

start.spring.io

Sachez que ce tutorial fonctionnera pour toutes les applications Java qui ont vocation à être exécutées via une commande du style java -jar MonApp.jar. Cela signifie que vous pourrez l’utiliser avec Micronaut ou encore Vert.x sans problème.

Dans le cas présent, j’utilise le plugin jib-maven-plugin mais sachez qu’il existe aussi un plugin Gradle avec jib-gradle-plugin

Ajout du plugin jib-maven-plugin

Il suffit d’ajouter le plugin suivant dans le pom.xml :

<project>
  ...
  <build>
    <plugins>
      <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
      ...
      <!-- Jib Plugin -->
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>0.9.10</version>
        <configuration>
          <to>
            <image>registry.hub.docker.com/davinkevin/spring-boot-demo-jib</image>
          </to>
        </configuration>
      </plugin>
      ...
    </plugins>
  </build>
  ...
</project>

Il vous suffit donc d’éxécuter la commande suivante pour publier votre image :

$ mvn compile jib:build
...
[INFO] --- jib-maven-plugin:0.9.10:build (default-cli) @ spring-boot-demo-jib ---
[WARNING] Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
[INFO]
[INFO] Containerizing application to davinkevin/spring-boot-demo-jib...
[INFO]
[INFO] Retrieving registry credentials for registry.hub.docker.com...
[INFO] Getting base image gcr.io/distroless/java...
[INFO] Building dependencies layer...
[INFO] Building resources layer...
[INFO] Building classes layer...
[INFO] Finalizing...
[INFO]
[INFO] Container entrypoint set to [java, -cp, /app/resources/:/app/classes/:/app/libs/*, com.github.davinkevin.springbootdemojib.SpringBootDemoJibApplicationKt]
[INFO]
[INFO] Built and pushed image as davinkevin/spring-boot-demo-jib
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 31.331 s
[INFO] Finished at: 2018-09-20T18:55:25Z
[INFO] ------------------------------------------------------------------------

Dans les faits, il faudra souvent ajouter un composant d’authentification pour pouvoir pousser son image sur le repository d’image que vous utilisez.

C’est à ce moment là qu’interviennent les docker-credential-helpers. Ce sont des outils qui permettent de déléguer la gestion des identifiants à des binaires externes.

Ces systèmes supportent différentes méthodes de gestion des identifiants :

Il suffit en général seulement d’ajouter à votre configuration de plugin le type du credential helper. Par exemple, avec Google Container Registry, cela donne :

<project>
    <plugins>
      ...
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>0.9.10</version>
        <configuration>
          <to>
            <image>gcr.io/my-project-id/spring-boot-demo-jib</image>
            <credHelper>gcr</credHelper>
          </to>
        </configuration>
      </plugin>
      ...    
    </plugins>
</project>

Ou si vous ne pouvez passer que par de l’authentification basique, la balise auth vous permettra de fournir vos identifiants.

<project>
    <plugins>
      ...
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>0.9.10</version>
        <configuration>
          <to>
            <image>my-company-image-repository.com/my-id/my-app</image>
            <auth>
              <username>${env.REGISTRY_USERNAME}</username>
              <password>${env.REGISTRY_PASSWORD}</password>
            </auth>
          </to>
        </configuration>
      </plugin>
      ...    
    </plugins>
</project>

Comme vous pouvez le voir dans l’exemple, il est important d’utiliser des variables d’environnements afin de ne surtout pas commiter vos username/password 😱

Et voilà, grâce à Jib et son plugin Maven (disponible aussi pour Gradle, pas de jaloux 😊), vous êtes maintenant capable de créer vos images Docker simplement et de manière plus efficace depuis n’importe quel environnement !

Pour plus d’informations, retrouvez la doc du plugin jib-maven-plugin.

comments powered by Disqus