Gestion dynamique de Dockerfile pour différents locataires dans la mise en œuvre du pipeline CI / CD

J'essaie d'implémenter le pipeline CI / CD pour mon projet en utilisant Docker, Kubernetes et Jenkins. Mon application est une application multi-locataire dans laquelle les variables d'application de base de données sont différentes pour chaque locataire.

Stratégie d'application

Lorsque je crée une image Docker, j'utilise un Dockerfile. Et je garde mon Dockerfile dans mon dépôt de code SVN. Pour chaque locataire, le référentiel de code est le même. Lorsque je crée une image, à ce moment-là, je dois créer différentes images pour différents locataires.

Implémentation de Dockerfile

Dans mon fichier Docker, j'ajoute un point d'entrée comme le suivant,

ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=tenant1config" , "TestProject.war"]

Si je dois créer une image Docker pour un autre locataire, je dois ajouter
-Dspring.profiles.active=tenant2config

Le point d'entrée dans le Dockerfile est donc dynamique.

Ma confusion

1. Pour gérer la commande de point d'entrée à l'intérieur du Dockerfile est possible par dynamiquement?
2. Ou dois-je ajouter un autre Dockerfile pour un autre locataire? Et vous devez exécuter la commande docker build séparément pour un locataire distinct?

Comment puis-je trouver un bon moyen standard de mise en œuvre de ce problème?

Citation de 12 Factor - Config

La configuration d'une application est tout ce qui est susceptible de varier entre les déploiements (staging, production, environnements de développement, etc.). Ceci comprend:

• Poignées de ressources vers la base de données, Memcached et d'autres services de support

• Informations d'identification pour les services externes tels qu'Amazon S3 ou Twitter

• Valeurs par déploiement telles que le nom d'hôte canonique pour le déploiement

Vous ne devez pas créer d'images Docker distinctes pour chaque locataire car le binaire doit être le même et toutes les configurations d'exécution doivent être injectées via l'environnement.

Il existe différentes options pour injecter la configuration d'exécution

1. Variables d'environnement

Au lieu de coder en dur le profil dans le point d'entrée, ajoutez une variable d'environnement

ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=$TENANT_PROFILE" , "TestProject.war"]

Injectez ensuite la variable d'environnement à partir de la configuration de déploiement de kubernetes Reportez-vous à https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/

2. Montez la configuration de profil en tant que config et référez-la

Votre point d'entrée ressemblera à

ENTRYPOINT ["java", "-jar", --spring.config.location="file:/path/to/tenantconfig.yaml" , "TestProject.war"] Montez ensuite le fichier de configuration requis en tant que configuration kubernetes.

Dans les deux cas, externalisez la configuration d'exécution à partir de l'image du docker et injectez-la via la configuration de déploiement en tant que variable d'environnement ou configuration.

Vous pouvez faire usage de docker ARGS, cela ne sera disponible qu'au moment de la construction et cela peut être utilisé au point d'entrée.

docker build --build-arg CONFIG_FILE=<file_name> -t tag_name .

CONFIG_FILE contiendra l'emplacement du fichier de configuration et vous pouvez le transmettre dynamiquement. Remplacez votre point d'entrée par$CONFIG_FILE

ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=$CONFIG_FILE" , "TestProject.war"]

Refer - Meilleures pratiques Dockerfile

ENTRYPOINT vous aide à configurer un conteneur pour qu'il s'exécute en tant qu'exécutable pouvant prendre des arguments à l'exécution

Toute propriété dynamique que vous souhaitez remplacer peut être effectuée lors de l'exécution avec la même image.

Vous pouvez passer l'argument nécessaire lors de l'exécution.