Déployer son application Jhipster dockerisée sur Heroku

Cet article fait suite à celui sur Démarrer avec Jhipster dans Docker

Tout ça c'est bien mais nous allons voir comment personnaliser votre image general03/coocotte.

Voici le réseau que nous allons mettre en place

1) Préparer le build

On va commencer par installer, via NPM, dans le container les outils suivants :

• Mettez à jour npm :

  npm install -g npm

• Installez Yeoman pour gérer bower et gulp :

  npm install -g yo

• Installez Bower pour les dépendences JS :

  npm install -g bower

• Installez Gulp pour lancer les commandes de deploy :

  npm install -g gulp-cli

• Installez BrowserSync pour recharger la page lors de modification de fichiers :

  npm install -g browser-sync

• Installez Jhipster :

  npm install -g generator-jhipster

• Et installez Yarn le nouveau gestionnaire de dépendances utilisé dans Jhipster

  npm install -g yarn

Nous allons adapter le fichier Dockerfile, qui est lancé lors d'un build docker

# Permet de construire notre image à partir de Java 8 

FROM openjdk:8-jre-alpine 

# Equivalent de "docker run -v" pour créer un autre volume de destination 

# On copie nos fichiers locaux dans le container 

# Comme nous avons récupérer les sources JS on les copie dans le container COPY . /coocotte ENV JHIPSTER_SLEEP 0 

# Renomme le package war 

ADD target/*.war /app.war 

# On modifie la date de modification pour que docker le prenne en compte 

RUN sh -c 'touch /app.war' 

# Spring Boot travaille dans ce dossier au besoin 

VOLUME /tmp 

# Container ecoute le port 8080 

EXPOSE 8080 

RUN echo "The application will start in ${JHIPSTER_SLEEP}s..." && \ sleep ${JHIPSTER_SLEEP} 

# Djava.security.egd=file:/dev/./urandom permet de reduire le temps de démarrage de tomcat 

ENV JAVA_OPTS="" 

ENTRYPOINT [ "sh", "-c", "java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.war" ]

Vous trouverez une explication des tags du Dockerfile sur la doc officielle

Ajoutez --no-bin-links dans le pom.xml à ce niveau

<execution> <id>yarn install</id> <goals> <goal>yarn</goal> </goals> <configuration> <arguments>install --no-bin-links</arguments> </configuration> </execution>

Cela évite les erreurs de liens symboliques comme nous sommes sous Windows. Une fois bien configuré votre Dockefile il reste plus qu'à valider le fichier.

$ docker build "C:\Users\votreUser\Documents\coocotte\app\src\main\docker"

On va maintenant lancer un build pour l'envoyer ensuite en production.

$ docker exec -it coocotte bash 

$ cd jhipster/app 

# un build via maven 

# -Pprod permet de générer le war (utilise le profile prod) 

$ ./mvnw -Pprod package -DskipTests=true 

# ou alors lancer avec le profil de dev 

#./mvnw -DskipTests=true 

# on lancer les services 

$ docker-compose -f src/main/docker/app.yml up -d

Notre fichier app.yml permet de lancer les services des containers.

Copier le code
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
version: '1'
services:
    gordon-app:
        image: gordon
        external_links:
            - coocotte-postgresql:postgresql
        environment:
            - SPRING_PROFILES_ACTIVE=prod,swagger
            - SPRING_DATASOURCE_URL=jdbc:postgresql://postgresql:5432/gordon
            - JHIPSTER_SLEEP=10 # gives time for the database to boot before the application
        ports:
            - 8080:8080
    gordon-postgresql:
        extends:
            file: postgresql.yml
            service: coocotte-postgresql

Il faut attendre au moins 10 sec que tout soit initialisé car dans ce fichier vous pouvez voir l'instruction JHIPSTER_SLEEP

On va regarder l'IP où est exposé mon application avec

$ docker-machine ip

Allez ensuite sur http://192.168.99.100:8080

2) Déployer sur Heroku

Nous allons maintenant déployer notre application sous Heroku.

On commence par créer un compte Heroku afin de créer votre application, coocotte.

Ensuite installez le toolbelt heroku en vous référent à la doc

Entrez dans le container coocotte en root

$ docker exec --user root -it coocotte bash

et saisir

$ wget https://cli-assets.heroku.com/branches/stable/heroku-linux-amd64.tar.gz -O heroku.tar. gz 

$ mkdir -p /usr/local/lib 

$ tar -xvzf heroku.tar.gz -C /usr/local/lib 

$ /usr/local/lib/heroku/install 

heroku installed to /usr/local/bin/heroku 

heroku-cli/5.7.1-c574890 (linux-amd64) go1.7.5 

root@83418de5c1a2:/home/jhipster/app# heroku 

Enter your Heroku credentials. 

Email: drigaudie@***.fr 

Password (typing will be hidden): 

Logged in as drigaudie@***.fr 

▸ Add apps to this dashboard by favoriting them with heroku apps:favorites:add 

See all add-ons with heroku addons 

See all apps with heroku apps --all 

See other CLI commands with heroku help

Sortez du container pour se connecter avec un utilisateur non root cette fois

$ docker exec -it coocotte bash

Commencez pas vous connecter à Heroku

$ heroku login 

Enter your Heroku credentials: 

Email: drigaudie@yahoo.fr 

Password: ********* 

Logged in as drigaudie@yahoo.fr

Puis lancez le déploiement de votre application sur Heroku

yo jhipster:heroku

Vous pouvez avoir une erreur il faut dans ce cas lancer le déploiement à la main

heroku deploy:jar target/coocotte-0.0.1-SNAPSHOT.war --app coocotte

Maintenant on accède à l'application via https://coocotte.herokuapp.com

Si on veut mettre un autre domaine il faut suivre la doc

3) Pousser son code open source

Maintenant que notre application est en ligne on va la pousser sous Github et ensuite sous le hub docker.

Pour commencer il faut avoir un repository docker en tant que "Automated Build"

Il faut lier votre compte Docker à votre Github

Après la création vous voyez un service docker apparaitre dans "Settings / integrations & services" de Github

Ainsi dès que l'on va faire un commit sur le dépôt GIT, le container docker sera mis à jour automatiquement.
On va préparer le commit

git init 

git config --global user.name "general03" 

git config --global user.email "drigaudie@***.fr" 

git remote add origin git@github.com:general03/coocotte.git 

touch .gitignore 

echo '/src/main/docker/postgresql.yml' >> .gitignore 

echo '/src/main/resources/config/application*.yml' >> .gitignore

Pensez à mettre vos fichiers de config dans .gitignore (comme fait ci dessus pour ceux de Jhipster) et aussi de remplacer ces fichiers par un ".sample".

Il faut aussi penser à commiter le war car il sera nécessaire pour faire le duild docker. Pour cela modifer la partie suivante dans .gitignore

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

# Maven 

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

/log/ 

/target/* # Ajouter * à la fin 

!target/*.war # Permet de ne pas ignorer le war

Maintenant on va mettre tout ça dans Github

git add . 

git commit -m 'Commit application code' 

git pull origin master 

git push origin master

Suite à cela votre code est à jour sous Github.

En accédant au hub docker on peut voir qu'un build est en cours

Cependant comme le Dockerfile n'est pas à la racine, le build fini en erreur. Une fois que vous aurez mis le Dockerfile au bon endroit tout rentrera dans l'ordre.

Une autre solution serait de passer par le Cloud Docker qui permet de spécifier le path du Dockerfile

Et voilà comment avoir une application déployer sur Heroku avec un code à jour dans Github et Docker Hub.