Les conteneurs Linux sont une solution puissante pour :
- Standardisation des logiciels
- Accélération du développement et des tests
- Gestion efficace des ressources tout au long du cycle de vie d’une application
Ici, nous fournirons un guide étape par étape pour créer des conteneurs Linux avec des applications destinées au déploiement dans le cloud. À titre d’exemple, nous utiliserons les conteneurs open source Alpaquita Stream de BellSoft hébergés sur la bibliothèque d’images de conteneurs Docker Hub.
Pour terminer le guide, vous devez avoir le démon docker installé et en cours d’exécution. Nous expliquerons comment extraire une image de conteneur sélectionnée du référentiel et l’exécuter avec Java, Python, des applications basées sur GCC et des images natives. Vous pouvez utiliser votre propre application ou créer un exemple de projet, comme indiqué ci-dessous.
Conteneurs Linux pour les applications Java
Extraire une image Docker
Pour créer un conteneur, exécutez :
$ docker image pull docker bellsoft/<repository>:<image_tag>
Démarrez le conteneur avec :
$ docker run -it --rm bellsoft/<repository>:<image_tag>
Vous pouvez également utiliser une commande combinée :
$ docker container run --rm -it bellsoft/<repository>:<image_tag>
Supposons que vous ayez choisi un conteneur d’exécution Liberica, qui inclut Alpaquita Stream basé sur musl (une option basée sur glibc est également disponible) et Liberica JDK Lite 11. La commande sera la suivante :
$ docker container run --rm -it bellsoft/liberica-runtime-container:jdk-11.0.17-musl
Notez que l’extraction d’une image n’est pas obligatoire mais recommandée si vous ne souhaitez pas extraire une image à chaque fois que vous répétez le processus de construction.
Écrire un Dockerfile et exécuter l’application
En utilisant une image JRE au lieu d’un JDK complet pour exécuter une application Java, vous réduisez la taille du conteneur d’env. 50 %.
Ainsi, dans le Dockerfile de notre application, nous spécifierons deux images – une pour créer une application et une autre pour l’exécuter. Nous utiliserons un projet Spring Petclinic standard comme exemple.
Écrivez le Dockerfile suivant :
FROM bellsoft/liberica-runtime-container:jdk-17-stream-musl as builder
WORKDIR /home/myapp
RUN apk add git
RUN git clone https://github.com/spring-projects/spring-petclinic.git
RUN cd spring-petclinic && ./mvnw package
FROM bellsoft/liberica-runtime-container:jre-17-stream-musl
WORKDIR /home/myapp
COPY --from=builder /home/myapp/spring-petclinic/target .
CMD ["java", "-jar", "spring-petclinic-3.0.0-SNAPSHOT.jar"]Créez l’image de l’application :
$ docker build --progress plain -t javaappimage .
Maintenant, exécutez l’image :
docker run -p 8080:8080 javaappimage
Fait! Ouvrez le navigateur pour accéder à l’application Petclinic.
Conteneurs Linux pour l’image native
Extraire une image Docker
Nous fournissons des images avec Liberica Native Image Kit (NIK), un utilitaire open source basé sur GraalVM pour convertir les applications JVM en exécutables natifs. Les développeurs qui travaillent avec des images natives ou envisagent d’intégrer la technologie dans leur projet peuvent extraire l’image suivante :
$ docker container run --rm -it bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl
Ou toute image que vous jugez appropriée en fonction de la version JDK et NIK et de l’implémentation de la libc (musl ou glibc optimisé de BellSoft).
Créer une image native
Commençons par écrire une application simple à convertir en un exécutable natif. Sinon, utilisez votre propre projet.
public class Example {
public static void main(String[] args) {
String str = "Native Image is awesome";
String reversed = reverseString(str);
System.out.println("The reversed string is: " + reversed);
}
public static String reverseString(String str) {
if (str.isEmpty())
return str;
return reverseString(str.substring(1)) + str.charAt(0);
}
}Le Dockerfile doit contenir les informations suivantes :
FROM bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl
WORKDIR /home/myapp
COPY Example.java /home/myapp
RUN javac Example.java
RUN native-image Example
FROM bellsoft/alpaquita-linux-base:stream-musl
WORKDIR /home/myapp
COPY --from=0 /home/myapp/example.
CMD ["./example"] Accédez au répertoire de l’application et exécutez :
$ docker build.
Voici le processus de construction de l’image :
[+] Building 370.9s (14/14) FINISHED
=> [internal] load build definition from Dockerfile 0.1s
=> => transferring dockerfile: 357B 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/bellsoft/alpaquita-linux-base:stream-musl 0.0s
=> [internal] load metadata for docker.io/bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl 4.8s
=> [internal] load build context 0.1s
=> => transferring context: 454B 0.0s
=> [stage-1 1/3] FROM docker.io/bellsoft/alpaquita-linux-base:stream-musl 0.1s
=> [stage-0 1/5] FROM docker.io/bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl@sha256:3c5a09abb2559cf0 293.4s
=> => resolve docker.io/bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl@sha256:3c5a09abb2559cf04e7527b81b 0.0s
=> => sha256:3c5a09abb2559cf04e7527b81bfa123ca52592ef2bce1512d837fbd0336440e9 951B / 951B 0.0s
=> => sha256:79998423fd609bb42881f8eb6721aa22451cdb46363b4fc5f49fc50390759138 2.72kB / 2.72kB 0.0s
=> => sha256:4f4293381c77f4d905cfa2034b4fe3adff4515508d08b0093a8db16728ba4879 3.34MB / 3.34MB 7.1s
=> => sha256:c3263c13b6f5c1ba5a386dc02047af54fdeefc8a92538ffc973915cdb0de9881 532.42kB / 532.42kB 7.0s
=> => sha256:f6c678d36153293dc6b01a73696b4ef60a9ecb44e62da72fd96b31e679f1ed2d 323.95MB / 323.95MB 284.4s
=> => extracting sha256:4f4293381c77f4d905cfa2034b4fe3adff4515508d08b0093a8db16728ba4879 0.1s
=> => extracting sha256:c3263c13b6f5c1ba5a386dc02047af54fdeefc8a92538ffc973915cdb0de9881 0.0s
=> => extracting sha256:f6c678d36153293dc6b01a73696b4ef60a9ecb44e62da72fd96b31e679f1ed2d 8.8s
=> [stage-1 2/3] WORKDIR /home/myapp 0.0s
=> [stage-0 2/5] WORKDIR /home/myapp 0.5s
=> [stage-0 3/5] COPY Example.java /home/myapp 0.0s
=> [stage-0 4/5] RUN javac Example.java 1.0s
=> [stage-0 5/5] RUN native-image Example 70.6s
=> [stage-1 3/3] COPY --from=0 /home/myapp/example . 0.1s
=> exporting to image 0.1s
=> => exporting layers 0.1s
=> => writing image sha256:f03df73515790f3ffe210fc139d5a0752c088fd242f571e19d111377f7703c6a 0.0sVérifiez que l’image a été créée.
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
<none> <none> f03df7351579 About a minute ago 19MBMarquez l’image nouvellement construite avec un nom significatif.
$ docker tag f03df7351579 bellsoft-nik:example-musl
$ docker run -it --rm f03df7351579
The reversed string is: emosewa si egamI evitaNConteneurs Linux pour Python
BellSoft fournit des images Alpaquita Linux avec Python 3.10 et des utilitaires Python de base (pip, setuptools, wheel). Deux options de libc (musl perf et glibc de BellSoft) sont disponibles.
Tout d’abord, écrivons une application flask simple :
$ cat requirements.txt
flask
markup
jinja2
$ cat test.py
from flask import Flask
app =...