Conteneuriser une application Java

Table des matières

Prérequis

Vous avez installé la dernière version de Docker Desktop. Docker ajoute régulièrement de nouvelles fonctionnalités et certaines parties de ce guide peuvent ne fonctionner qu'avec la dernière version de Docker Desktop.

Vous disposez d'un client Git. Les exemples de cette section utilisent un client Git en ligne de commande, mais vous pouvez utiliser n'importe quel client.

Aperçu

Cette section vous guide dans la conteneurisation et l'exécution d'une application Java.

Obtenir les applications d'exemple

Clonez l'application d'exemple que vous utiliserez sur votre machine de développement locale. Exécutez la commande suivante dans un terminal pour cloner le dépôt.

$ git clone https://github.com/spring-projects/spring-petclinic.git

L'application d'exemple est une application Spring Boot construite à l'aide de Maven. Pour plus de détails, consultez le fichier readme.md dans le dépôt.

Initialiser les ressources Docker

Maintenant que vous avez une application, vous pouvez créer les ressources Docker nécessaires pour la conteneuriser. Vous pouvez utiliser la fonctionnalité intégrée Docker Init de Docker Desktop pour aider à rationaliser le processus, ou vous pouvez créer manuellement les ressources.

À l'intérieur du répertoire spring-petclinic, exécutez la commande docker init. docker init fournit une configuration par défaut, mais vous devrez répondre à quelques questions sur votre application. Référez-vous à l'exemple suivant pour répondre aux invites de docker init et utilisez les mêmes réponses pour vos invites.

L'application d'exemple contient déjà des ressources Docker. Vous serez invité à écraser les ressources Docker existantes. Pour continuer avec ce guide, sélectionnez y pour les écraser.

$ docker init
Bienvenue dans l'interface de ligne de commande Docker Init !

Cet utilitaire vous guidera dans la création des fichiers suivants avec des valeurs par défaut pertinentes pour votre projet :
  - .dockerignore
  - Dockerfile
  - compose.yaml
  - README.Docker.md

Commençons !

AVERTISSEMENT : Les fichiers Docker suivants existent déjà dans ce répertoire :
  - docker-compose.yml
? Voulez-vous les écraser ? Oui
? Quelle plateforme d'application votre projet utilise-t-il ? Java
? Quel est le répertoire relatif (avec un . au début) pour votre application ? ./src
? Quelle version de Java voulez-vous utiliser ? 21
? Sur quel port votre serveur écoute-t-il ? 8080

Dans l'exemple précédent, remarquez l' AVERTISSEMENT. docker-compose.yaml existe déjà, donc docker init écrase ce fichier plutôt que de créer un nouveau fichier compose.yaml. Cela évite d'avoir plusieurs fichiers Compose dans le répertoire. Les deux noms sont pris en charge, mais Compose préfère le nom canonique compose.yaml.

Si vous n'avez pas Docker Desktop d'installé ou si vous préférez créer les ressources manuellement, vous pouvez créer les fichiers suivants dans le répertoire de votre projet.

Créez un fichier nommé Dockerfile avec le contenu suivant.

Dockerfile

# syntax=docker/dockerfile:1

# Des commentaires sont fournis tout au long de ce fichier pour vous aider à démarrer.
# Si vous avez besoin de plus d'aide, consultez le guide de référence Dockerfile à l'adresse
# https://docs.docker.com/go/dockerfile-reference/

# Vous voulez nous aider à améliorer ce modèle ? Partagez vos commentaires ici : https://forms.gle/ybq9Krt8jtBL3iCk7

################################################################################

# Créez une étape pour résoudre et télécharger les dépendances.
FROM eclipse-temurin:21-jdk-jammy as deps

WORKDIR /build

# Copiez le wrapper mvnw avec les autorisations d'exécution.
COPY --chmod=0755 mvnw mvnw
COPY .mvn/ .mvn/

# Téléchargez les dépendances dans une étape distincte pour profiter de la mise en cache de Docker.
# Tirez parti d'un montage de cache sur /root/.m2 pour que les builds ultérieures n'aient pas à
# retélécharger les paquets.
RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 ./mvnw dependency:go-offline -DskipTests

################################################################################

# Créez une étape pour construire l'application en fonction de l'étape avec les dépendances téléchargées.
# Ce Dockerfile est optimisé pour les applications Java qui génèrent un uber jar, qui inclut
# toutes les dépendances nécessaires pour exécuter votre application à l'intérieur d'une JVM. Si votre application ne génère pas d'uber
# jar et repose plutôt sur un serveur d'applications comme Apache Tomcat, vous devrez mettre à jour cette
# étape avec le nom de fichier correct de votre paquet et mettre à jour l'image de base de l'étape "finale"
# pour utiliser le serveur d'applications approprié, par exemple, en utilisant tomcat (https://hub.docker.com/_/tomcat/) comme image de base.
FROM deps as package

WORKDIR /build

COPY ./src src/
RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 \
    ./mvnw package -DskipTests && \
    mv target/$(./mvnw help:evaluate -Dexpression=project.artifactId -q -DforceStdout)-$(./mvnw help:evaluate -Dexpression=project.version -q -DforceStdout).jar target/app.jar

################################################################################

# Créez une étape pour extraire l'application en couches distinctes.
# Profitez des outils de couches de Spring Boot et de la mise en cache de Docker en extrayant
# l'application empaquetée en couches distinctes qui peuvent être copiées dans l'étape finale.
# Voir la documentation de Spring pour référence :
# https://docs.spring.io/spring-boot/docs/current/reference/html/container-images.html
FROM package as extract

WORKDIR /build

RUN java -Djarmode=layertools -jar target/app.jar extract --destination target/extracted

################################################################################

# Créez une nouvelle étape pour exécuter l'application qui contient les dépendances
# d'exécution minimales pour l'application. Cela utilise souvent une image de base différente
# de l'étape d'installation ou de construction où les fichiers nécessaires sont copiés
# depuis l'étape d'installation.
#
# L'exemple ci-dessous utilise l'image JRE d'eclipse-turmin comme base pour exécuter l'application.
# En spécifiant le tag "17-jre-jammy", il utilisera également la version
# la plus récente de ce tag lorsque vous construirez votre Dockerfile.
# Si la reproductibilité est importante, envisagez d'utiliser un SHA de digest spécifique, comme
# eclipse-temurin@sha256:99cede493dfd88720b610eb8077c8688d3cca50003d76d1d539b0efc8cca72b4.
FROM eclipse-temurin:21-jre-jammy AS final

# Créez un utilisateur non privilégié sous lequel l'application s'exécutera.
# Voir https://docs.docker.com/go/dockerfile-user-best-practices/
ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser
USER appuser

# Copiez l'exécutable de l'étape "package".
COPY --from=extract build/target/extracted/dependencies/ ./
COPY --from=extract build/target/extracted/spring-boot-loader/ ./
COPY --from=extract build/target/extracted/snapshot-dependencies/ ./
COPY --from=extract build/target/extracted/application/ ./

EXPOSE 8080

ENTRYPOINT [ "java", "org.springframework.boot.loader.launch.JarLauncher" ]

L'exemple contient déjà un fichier Compose. Écrasez ce fichier pour suivre le guide. Mettez à jour le docker-compose.yaml avec le contenu suivant.

docker-compose.yaml

# Des commentaires sont fournis tout au long de ce fichier pour vous aider à démarrer.
# Si vous avez besoin de plus d'aide, consultez le guide de référence Docker Compose à l'adresse
# https://docs.docker.com/go/compose-spec-reference/

# Ici, les instructions définissent votre application comme un service appelé "server".
# Ce service est construit à partir du Dockerfile dans le répertoire actuel.
# Vous pouvez ajouter ici d'autres services dont votre application peut dépendre, tels qu'une
# base de données ou un cache. Pour des exemples, consultez le dépôt Awesome Compose :
# https://github.com/docker/awesome-compose
services:
  server:
    build:
      context: .
    ports:
      - 8080:8080
# La section commentée ci-dessous est un exemple de la façon de définir une base de données PostgreSQL
# que votre application peut utiliser. `depends_on` indique à Docker Compose de
# démarrer la base de données avant votre application. Le volume `db-data` persiste les
# données de la base de données entre les redémarrages de conteneurs. Le secret `db-password` est utilisé
# pour définir le mot de passe de la base de données. Vous devez créer `db/password.txt` et ajouter
# un mot de passe de votre choix avant d'exécuter `docker compose up`.
#     depends_on:
#       db:
#         condition: service_healthy
#   db:
#     image: postgres
#     restart: always
#     user: postgres
#     secrets:
#       - db-password
#     volumes:
#       - db-data:/var/lib/postgresql/data
#     environment:
#       - POSTGRES_DB=example
#       - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
#     expose:
#       - 5432
#     healthcheck:
#       test: [ "CMD", "pg_isready" ]
#       interval: 10s
#       timeout: 5s
#       retries: 5
# volumes:
#   db-data:
# secrets:
#   db-password:
#     file: db/password.txt

Créez un fichier nommé .dockerignore avec le contenu suivant.

.dockerignore

# Incluez ici tous les fichiers ou répertoires que vous ne voulez pas copier dans votre
# conteneur (par exemple, les artefacts de construction locaux, les fichiers temporaires, etc.).
#
# Pour plus d'aide, consultez le guide de référence du fichier .dockerignore à l'adresse
# https://docs.docker.com/go/build-context-dockerignore/

**/.classpath
**/.dockerignore
**/.env
**/.git
**/.gitignore

Vous devriez maintenant avoir les trois fichiers suivants dans votre spring-petclinic répertoire.

Exécuter l'application

À l'intérieur du répertoire spring-petclinic, exécutez la commande suivante dans un terminal.

$ docker compose up --build

La première fois que vous construisez et exécutez l'application, Docker télécharge les dépendances et construit l'application. Cela peut prendre plusieurs minutes en fonction de votre connexion réseau.

Ouvrez un navigateur et visualisez l'application à http://localhost:8080. Vous devriez voir une application simple pour une clinique de médecine vétérinaire.

Dans le terminal, appuyez sur ctrl+c pour arrêter l'application.

Exécuter l'application en arrière-plan

Vous pouvez exécuter l'application détachée du terminal en ajoutant l'option -d. À l'intérieur du répertoire spring-petclinic, exécutez la commande suivante dans un terminal.

$ docker compose up --build -d

Ouvrez un navigateur et visualisez l'application à http://localhost:8080. Vous devriez voir une application simple pour une clinique de médecine vétérinaire.

Dans le terminal, exécutez la commande suivante pour arrêter l'application.

$ docker compose down

Pour plus d'informations sur les commandes Compose, consultez la référence de la CLI Compose.

Résumé

Dans cette section, vous avez appris comment vous pouvez conteneuriser et exécuter une application Java en utilisant Docker.

Informations connexes :

docker init reference

Étapes suivantes

Dans la section suivante, vous apprendrez à développer votre application en utilisant des conteneurs Docker.