Aller au contenu

Conteneurs Mis à jour le 2026-05-27

Construire un conteneur personnalisé

Écrire un Dockerfile sur un modèle de base Stack Harbor PaaS, bâtir l'image, la pousser vers un registre et la déployer sur la plateforme.

Cette page parcourt le flux complet de préparation d’une image Docker personnalisée pour le Stack Harbor PaaS : écrire un Dockerfile sur un modèle de base de la plateforme, bâtir l’image, la pousser vers un registre, et y pointer la plateforme. L’exemple bâtit un serveur d’application WildFly, mais la structure s’applique à toute image — choisir une base, empiler son logiciel, exposer les bons ports, déclarer un point d’entrée.

Il y a trois phases :

  • Composer le Dockerfile.
  • Bâtir et pousser l’image.
  • La déployer sur un environnement.

Composer le Dockerfile

Un Dockerfile est un manifeste texte que le démon Docker exécute pour bâtir une image. Chaque ligne est une instruction ; le démon les exécute en ordre et capture le résultat.

1. Choisir une base

Utilisez la base AlmaLinux 9 de la plateforme — elle porte la configuration attendue par le PaaS pour supervision, SSH, journalisation et cycle de vie.

FROM almalinux:9

Pour des images qui exigent une autre distribution, voir les exigences d’image de conteneur pour la liste des bases supportées.

2. Métadonnées et variables

LABEL porte les métadonnées (mainteneur, version, description). ENV déclare les variables d’environnement que les étapes RUN suivantes peuvent interpoler et que le conteneur héritera à l’exécution.

LABEL maintainer="ops@example.com"
ENV WILDFLY_VERSION=36.0.0.Final
ENV ADMIN_USER=admin
ENV ADMIN_PASSWORD=admin

ADMIN_PASSWORD devrait être remplacé après le premier déploiement — gravez un défaut manifestement provisoire pour qu’il soit facile à repérer.

3. Installer les dépendances d’exécution

RUN exécute des commandes shell pendant le build. Pour WildFly il faut un JDK et tar pour décompacter la distribution.

RUN dnf -y install java-17-openjdk-devel tar && dnf -y update

4. Récupérer et décompacter l’application

Téléchargez la distribution WildFly depuis la release officielle, décompactez sous /opt, nettoyez l’archive.

RUN cd /opt \
    && curl -LO https://github.com/wildfly/wildfly/releases/download/$WILDFLY_VERSION/wildfly-$WILDFLY_VERSION.tar.gz \
    && tar xf wildfly-${WILDFLY_VERSION}.tar.gz \
    && rm wildfly-${WILDFLY_VERSION}.tar.gz

5. Lien symbolique pratique

Un chemin stable /opt/wildfly rend les fichiers de configuration ultérieurs agnostiques à la version.

RUN ln -s /opt/wildfly-$WILDFLY_VERSION /opt/wildfly

6. Fichier de configuration du serveur

WildFly lit ses options de lancement depuis un fichier sysconfig. Gravez le chemin, l’emplacement des journaux et les adresses de liaison dans l’image.

RUN echo -en "WILDFLY_SH=/opt/wildfly/bin/standalone.sh\n\
WILDFLY_SERVER_CONFIG=standalone.xml\n\
WILDFLY_CONSOLE_LOG=/var/log/wildfly/console.log\n\
WILDFLY_OPTS=\"-b 0.0.0.0 -bmanagement=0.0.0.0 -Djboss.management.http.port=4949 -Djboss.management.https.port=4848 -Djboss.server.log.dir=/var/log/wildfly/\"\n" \
    >> /etc/sysconfig/wildfly-standalone.conf

7. Unité systemd

AlmaLinux 9 et WildFly 36 utilisent systemd. Déposez le fichier d’unité fourni par WildFly dans /etc/systemd/system.

RUN cp /opt/wildfly-$WILDFLY_VERSION/bin/systemd/wildfly-standalone.service /etc/systemd/system/wildfly.service

8. Utilisateur de service, répertoire de journaux, permissions

RUN systemctl enable wildfly \
    && mkdir -p /var/log/wildfly \
    && adduser wildfly \
    && chown -R wildfly:wildfly /opt/wildfly-$WILDFLY_VERSION /opt/wildfly /var/log/wildfly

9. TLS auto-signé pour le panneau admin

RUN cd /opt/wildfly/standalone/configuration \
    && keypass=password \
    && keytool -genkeypair -alias serverkey -keyalg RSA -keysize 4096 -validity 7360 \
        -keystore application.keystore -keypass $keypass -storepass $keypass \
        -dname "cn=Server Administrator,o=Acme,c=GB" \
    && chown wildfly:wildfly application.keystore

Les déploiements de production devraient remplacer ceci par un vrai certificat — la clé auto-signée n’est acceptable que pour la mise en route initiale.

10. Utilisateur admin

RUN /opt/wildfly/bin/add-user.sh --user $ADMIN_USER --password $ADMIN_PASSWORD --silent --enable

11. Locale, exposition des ports, point d’entrée

RUN localedef -i en_US -f UTF-8 en_US.UTF-8

EXPOSE 22 80 443 8080 8743 9990 9993 8009 4848 4949

ENTRYPOINT ["/bin/bash"]

EXPOSE déclare les ports qu’ouvre l’image — la plateforme utilise cette liste pour le câblage DNS et répartiteur. ENTRYPOINT définit le processus lancé au démarrage du conteneur ; voir configuration d’exécution pour le mappage tableau de bord vers ENTRYPOINT et CMD.

Bâtir et pousser l’image

Une fois le Dockerfile en place, bâtissez et poussez depuis un poste avec Docker installé.

1. Build

sudo docker build -t {image_name} {dockerfile_location}
  • {image_name} — nom du dépôt avec un tag optionnel (par ex. examplerepo/wildfly:latest). Sans tag, Docker prend latest.
  • {dockerfile_location} — chemin local ou URL. . si le Dockerfile est dans le répertoire courant.

2. Vérifier

sudo docker images

La nouvelle image doit être dans la liste.

3. Pousser

sudo docker push {image_name}

{image_name} est la même chaîne qu’au build. Le premier push demande les identifiants du registre ; vous pouvez éviter l’invite en lançant docker login à l’avance — les identifiants sont alors stockés dans ~/.docker/config.json.

Déployer sur la plateforme

Une fois l’image au registre, pointez un environnement Stack Harbor PaaS dessus via l’assistant de topologie.

  1. Cliquez sur New Environment dans le tableau de bord. Passez à l’onglet Custom. Cliquez sur Select Image.
  2. Passez au sous-onglet Custom (ou Search si l’image est sur Docker Hub public). Cliquez sur Add New Image.
  3. Renseignez Name avec [{registry_hostname}/]{namespace}/{image_name} — l’hôte du registre est optionnel pour Docker Hub, requis ailleurs.
  4. Pour un registre privé, renseignez Username et Password. Sinon laissez vides.
  5. Cliquez sur Add. L’image apparaît dans la liste Custom.
  6. Sélectionnez l’image sur le palier voulu (choix typique pour un serveur d’app : le palier Application Servers ; le répartiteur partagé de la plateforme s’y branche automatiquement). Configurez le reste du palier — nombre d’instances, redimensionnement, points de montage, variables.
  7. Cliquez sur Create.

L’environnement se provisionne en quelques minutes. Open in Browser sur le palier ouvre le domaine de l’application.

Pour WildFly spécifiquement, la page d’accueil répond sur le domaine par défaut, et la console admin est joignable par le lien sur cette page. Connectez-vous avec les identifiants gravés au Dockerfile (admin/admin dans cet exemple) — tournez-les immédiatement.

Voir aussi