<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Maxime Vanmeerbeck on Medium]]></title>
        <description><![CDATA[Stories by Maxime Vanmeerbeck on Medium]]></description>
        <link>https://medium.com/@mvanmeerbeck?source=rss-f02dbbe1a166------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YomnXpBC2JryS7wPcV-aSg.png</url>
            <title>Stories by Maxime Vanmeerbeck on Medium</title>
            <link>https://medium.com/@mvanmeerbeck?source=rss-f02dbbe1a166------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 19:51:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mvanmeerbeck/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Pourquoi l’absentéisme politique est-il aussi fort ?]]></title>
            <link>https://medium.com/@mvanmeerbeck/pourquoi-labsent%C3%A9isme-politique-est-il-aussi-fort-b66d8083eea?source=rss-f02dbbe1a166------2</link>
            <guid isPermaLink="false">https://medium.com/p/b66d8083eea</guid>
            <category><![CDATA[élections]]></category>
            <category><![CDATA[abstention]]></category>
            <category><![CDATA[politique]]></category>
            <category><![CDATA[citoyen]]></category>
            <dc:creator><![CDATA[Maxime Vanmeerbeck]]></dc:creator>
            <pubDate>Tue, 29 Jun 2021 14:32:31 GMT</pubDate>
            <atom:updated>2021-06-29T14:32:31.578Z</atom:updated>
            <content:encoded><![CDATA[<h3>Pourquoi l’absentéisme politique est-il aussi fort ?</h3><p>Tandis que L’Euro 2021 de football crève l’audimat, les élections régionales et départementales n’ont jamais eu un taux d’abstention aussi fort: 2 personnes sur 3 ne sont pas allées voter. Faute au covid ? A un manque de communication ? Ce sont certainement des facteurs aggravants mais le cœur du problème n’est pas récent, l’abstention augmente studieusement depuis plus de 50 ans, notamment pour les élections locales.</p><p>Au premier abord, nous pourrions penser à une crise de notre système démocratique, à cette soit disant technocratie qui ne répond pas aux attentes des citoyens et de la société, de ses rouages techniques rouillés. Ces remarques sous-entendent que l’origine des maux est extérieur à soi même: la société doit être au service de ses membres. Au contraire, la société n’est que le reflet et la symbiose de ses citoyens. Combien de fois entendons-nous l’expression “mais que fait l’Etat ?”; ces personnes considèrent l’Etat comme un prestataire de services: liberté, égalité, fraternité mais surtout liberté et sans les devoirs.</p><h3>Nous avons créé des ado-citoyens sans aucune conscience civique.</h3><p>Des citoyens qui ne n’en sont pas. Des exo-citoyens considérant la société comme extérieure à leur vie mais qui leur est redevable.</p><p>Ce manque de conscience civique est apparu insidieusement à la fin du XXème siècle où l’ère des grandes idéologies (communisme, fascisme, libéralisme, etc) touchait à sa fin et laissait place à l’individualisme d’abord américain, maintenant mondial.</p><p>Aujourd’hui, une nouvelle conscience politique apparaît suite au danger que représente le réchauffement climatique. Cependant, nous assistons à la contradiction de deux jeunesses: l’écologie à tout prix mais la liberté sans contrainte.</p><h3>Pourquoi un absentéisme plus fort au niveau local ?</h3><p>L’absentéisme au niveau local est d’autant plus inquiétant car la politique locale est généralement exempt du spectacle de la politique nationale. Cette télépolitique a l’effet d’intéresser beaucoup plus de monde pour les mauvaises raisons. Donc, l’absentéisme aux élections locales est un thermomètre idéal pour mesurer la santé d’une démocratie.</p><p>Quand il n’y a plus de spectacle, il ne reste que des acteurs, et ils sont peu nombreux. Il y a désintérêt pour les problématiques concrètes, de terrain excepté quand ce terrain vous appartient.</p><h3>Que faire de ce constat ?</h3><p>Ce constat est connu depuis des dizaines d’années. Je pense que la clé passe par l’éducation et l’implication des citoyens dans la vie de la société. Malheureusement, j’ai le sentiment que tout le monde ne peut pas être sensibiliser sur les questions civiques. Peut-être devrions-nous revenir au système romain où seuls les citoyens peuvent voter ? Et devenir citoyen serait soumis à un examen comme le permis de conduire.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b66d8083eea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[De l’environnement de développement à la production avec Docker Swarm, GitLab et Google Cloud]]></title>
            <link>https://medium.com/the-blockchain-xdev/de-lenvironnement-de-d%C3%A9veloppement-%C3%A0-la-production-avec-docker-swarm-gitlab-et-google-cloud-584daccfb813?source=rss-f02dbbe1a166------2</link>
            <guid isPermaLink="false">https://medium.com/p/584daccfb813</guid>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[docker-swarm]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Maxime Vanmeerbeck]]></dc:creator>
            <pubDate>Mon, 02 Dec 2019 08:01:01 GMT</pubDate>
            <atom:updated>2020-07-20T09:18:33.787Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>L’objectif de ce tutorial est d’étudier dans la pratique le cycle de vie d’une application depuis l’environnement de développement jusqu’à la mise en production en suivant la méthodologie du déploiement continu.<br>Le cycle de vie d’une application peut être divisé en trois étapes principales:</p><ul><li>le développement</li><li>les tests</li><li>le déploiement en production</li></ul><p>Dans cette optique, nous allons baser notre travail autour de Docker et ses outils Docker Compose et Docker Swarm.<br>Afin de tester l’application, nous verrons dans une seconde partie l’outil GitLab, ses pipelines et l’utilisation d’un registre privé.<br>Enfin dans la dernière partie, nous mettrons en place un déploiement continu depuis Gitlab sur Google Cloud grâce Docker Swarm.<br>Le projet consistera en une simple API RESTful conçue avec Spring Boot et une base de donnée MongoDB qui sera développée, testée puis déployée grâce à ces outils.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TdTcbkH9nAIIKpIysmt8PA.jpeg" /><figcaption>Effigie de GitLab et clickbait (Photo de <a href="https://unsplash.com/@olga_kononenko?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Olga Kononenko</a>)</figcaption></figure><h3>Environnement de développement</h3><h3>Initialisation du projet</h3><p>La première étape consiste à créer le projet sur GitLab. GitLab propose un système très pratique de template pour charger un framework en particulier. Le projet sera créé avec tous les fichiers nécessaires pour démarrer Spring Boot:</p><ul><li>rendez-vous sur <a href="https://gitlab.com/projects/new">la page de création de projet</a></li><li>cliquez sur l’onglet “<em>Create from template</em>”</li><li>cliquez sur “<em>Use template</em>” sur la ligne de Spring</li><li>remplissez le formulaire: “<em>Project name</em>”, “<em>description</em>” et “<em>visibility</em>”</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/0*SnC2tmS3zpeZkeI_" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/0*9wOqWnznJDjwvRaN" /></figure><p>Afin de cloner le projet sur votre machine locale, renseignez votre clé ssh dans les paramètres de GitLab. Pour obtenir votre clé ssh publique, exécutez cette commande dans un terminal et copiez le résultat dans le formulaire:</p><pre>cat ~/.ssh/id_rsa.pub</pre><p>Une fois votre clé ajoutée, vous pouvez cloner le projet (en haut à droite, le bouton “Clone”) dans le dossier de votre choix:</p><pre>git clone git@gitlab.com:maximevanmeerbeck/spring-boot-from-dev-to-prod.git<br>cd spring-boot-from-dev-to-prod/</pre><p>Spring Boot dispose d’un wrapper pour lancer l’application. Il faut d’abord donner les droits d’exécution au wrapper, puis lancez l’application pour vérifier son bon fonctionnement:</p><pre>chmod +x ./mvnw<br>./mvnw spring-boot:run</pre><p>L’objectif de l’application est de renvoyer une liste d’utilisateurs contenue dans une base de donnée MongoDB. Nous allons utiliser Docker et Docker Compose pour déployer l’application et la base de donnée MongoDB dans des conteneurs en local.</p><h3>Services de l’application avec Docker</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*nVu_2WHaWzcwA2-pTG79Wg.jpeg" /><figcaption>Moins mignon que le renard, Docker a choisi la baleine comme logo</figcaption></figure><p>Tout d’abord, Il est nécessaire d’installer <a href="https://docs.docker.com/install/">Docker</a>. Pour vérifier que Docker et Docker Compose sont bien installés, vous pouvez exécuter ces commandes:</p><pre>$ docker -v<br>Docker version 19.03.4, build 9013bf583a</pre><pre>$ docker-compose -v<br>docker-compose version 1.24.0, build 0aa5906</pre><p>Docker permet d’exécuter des applications isolées dans un conteneur contenant toutes les dépendances nécessaires. Dans notre contexte, nous avons besoin d’un conteneur pour MongoDB et d’un autre pour l’application Spring Boot.<br>Docker Compose permet de … composer son architecture de conteneurs.</p><p>Créez d’abord un fichier docker-compose.yml à la racine du projet pour déclarer vos deux conteneurs.</p><pre>version: &#39;3&#39;<br>services:<br> spring-boot:<br> image: xdev/spring-boot-from-dev-to-prod<br> build: .<br> restart: always<br> ports:<br>   - 8080:8080<br> depends_on:<br>   - mongo<br> mongo:<br> image: mongo<br> ports:<br>   - 27017:27017<br> volumes:<br>   - mongodb:/data/db<br>   - mongodb_config:/data/configdb<br>volumes:<br> mongodb:<br> mongodb_config:</pre><p>Le conteneur MongoDB s’appuie sur l’image mongo déjà compilée qui est récupérée sur Docker Hub. Afin de simplifier le développement, vous allez ouvrir le port 27017 du conteneur pour y accéder depuis un client MongoDB comme Compass ou Robo3T. Les deux volumes sont nécessaires pour que les données soient persistantes.<br>En revanche, pour l’application Spring Boot, l’image n’existe pas encore. Il faut construire l’image avec un fichier Dockerfile qui est une sorte de patron, une suite de commandes expliquant comment créer l’image de notre application. La construction de votre image se fait avec la clé “build” à laquelle vous pouvez passer le contexte et le nom du fichier Dockerfile. Par défaut, Docker Compose charge le fichier Dockerfile à la racine.<br>Spring Boot propose une version en deux passes du fichier Dockerfile sur leur site.</p><pre>FROM openjdk:8-jdk-alpine as build<br>WORKDIR /workspace/app</pre><pre>COPY mvnw .<br>COPY .mvn .mvn<br>COPY pom.xml .<br>COPY src src</pre><pre>RUN ./mvnw install -DskipTests<br>RUN mkdir -p target/dependency &amp;&amp; (cd target/dependency; jar -xf ../*.jar)</pre><pre>FROM openjdk:8-jdk-alpine<br>VOLUME /tmp<br>ARG DEPENDENCY=/workspace/app/target/dependency<br>COPY --from=build ${DEPENDENCY}/BOOT-INF/lib /app/lib<br>COPY --from=build ${DEPENDENCY}/META-INF /app/META-INF<br>COPY --from=build ${DEPENDENCY}/BOOT-INF/classes /app<br>ENTRYPOINT [&quot;java&quot;,&quot;-cp&quot;,&quot;app:app/lib/*&quot;,&quot;com.example.demo.DemoApplication&quot;]</pre><p>Il existe deux commandes pour construire votre image. La première ne fait que construire les images alors que la deuxième lance en plus les conteneurs.</p><pre>docker-compose build<br>docker-compose up -d --build</pre><p>Une fois les conteneurs lancés, vérifiez que l’application tourne correctement en consultant les logs avec la commande:</p><pre>docker-compose logs -f</pre><h3>L’application Spring Boot</h3><p>Quelques modifications sont à effectuer sur l’application pour construire notre API d’utilisateurs.<br>D’abord, installez MongoDB en ajoutant la dépendance dans le fichier pom.xml. Profitez-en pour changer le nom et la description du projet ainsi que la version de Spring Boot en 2.1.0.RELEASE:</p><pre>&lt;<strong>dependency</strong>&gt;<br> &lt;<strong>groupId</strong>&gt;org.springframework.boot&lt;/<strong>groupId</strong>&gt;<br> &lt;<strong>artifactId</strong>&gt;spring-boot-starter-data-mongodb&lt;/<strong>artifactId</strong>&gt;<br>&lt;/<strong>dependency</strong>&gt;</pre><p>Docker Compose crée un réseau commun entre tous les conteneurs. Par défaut chaque conteneur a comme host son nom. Donc MongoDB est accessible via le host mongo, sur le port 27017 à l’intérieur du conteneur spring-boot. Vous devez donc ajouter le paramètre host dans le fichier application.properties.</p><pre>spring.data.mongodb.host=mongo</pre><p>Il faut reconstruire l’image et relancer le conteneur spring-boot pour voir les modifications.</p><pre>docker-compose up -d --build</pre><p>La construction de l’image prend un certain temps, il n’est pas donc pas pratique de reconstruire l’image après chaque modification. J’ai une astuce pour pallier ce problème. Il est tout à fait possible de continuer à travailler sur son application sans passer par Docker. En revanche, il faut ajouter le host mongo sur la machine locale, en sudo:</p><pre>echo &quot;127.0.0.1 mongo&quot; &gt;&gt; /etc/hosts</pre><pre>docker-compose down<br>docker-compose up -d mongo<br>./mvnw spring-boot:run</pre><p>Il existe également une autre solution en modifiant le Dockerfile et en créant un volume entre les fichiers de l’application de la machine host et du conteneur.<br>Modifiez l’application pour répondre à notre besoin.<br>Créez une application “Application” dans un nouveau package “xdev” qui sera le point d’entrée de l’application.</p><pre>package xdev;</pre><pre>import org.springframework.boot.*;<br>import org.springframework.boot.autoconfigure.*;<br>import org.springframework.web.bind.annotation.*;</pre><pre>@SpringBootApplication<br>@RestController<br>public class Application {<br> public static void main(String[] args) {<br> SpringApplication.run(Application.class, args);<br> }<br>}</pre><p>Il faut modifier en conséquence le fichier Dockerfile pour le faire pointer vers la nouvelle application puis relancez l’application pour vérifier que tout fonctionne correctement.</p><pre>ENTRYPOINT [&quot;java&quot;,&quot;-cp&quot;,&quot;app:app/lib/*&quot;,&quot;xdev.Application&quot;]</pre><p>Ajoutez un contrôleur, une modèle et un dépôt pour gérer les utilisateurs.<br>Le modèle User représente notre utilisateur composé d’un id, prénom, nom et email. L’id est une string dans le paradigme de MongoDB (hash). L’annotation @Id indique à Spring Boot que ce champ correspond à la clé primaire.</p><pre>package xdev.model;</pre><pre>import org.springframework.data.annotation.Id;</pre><pre>public class User {<br> @Id<br> public String id;<br> public String username;<br> public String firstname;<br> public String lastname;<br> public String email;</pre><pre> public User(String username, String firstname, String lastname, String email) {<br> this.username = username;<br> this.firstname = firstname;<br> this.lastname = lastname;<br> this.email = email;<br> }</pre><pre> public String getUsername() {<br> return username;<br> }</pre><pre> public void setUsername(String username) {<br> this.username = username;<br> }</pre><pre> public String getFirstname() {<br> return firstname;<br> }</pre><pre> public void setFirstname(String firstname) {<br> this.firstname = firstname;<br> }</pre><pre> public String getLastname() {<br> return lastname;<br> }</pre><pre> public void setLastname(String lastname) {<br> this.lastname = lastname;<br> }</pre><pre> public String getEmail() {<br> return email;<br> }</pre><pre> public void setEmail(String email) {<br> this.email = email;<br> }<br>}</pre><p>Ajoutez un dépôt associé au modèle User pour gérer les requêtes</p><pre>package xdev.repository;</pre><pre>import org.springframework.data.mongodb.repository.MongoRepository;<br>import xdev.model.User;</pre><pre>public interface UserRepository extends MongoRepository&lt;User, String&gt; {</pre><pre>}</pre><p>Le contrôleur vous permet de déclarer les routes de notre l’API</p><pre>package xdev.controller;</pre><pre>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.http.HttpStatus;<br>import org.springframework.web.bind.annotation.*;<br>import xdev.model.User;<br>import xdev.repository.UserRepository;</pre><pre>import java.util.List;</pre><pre>@RestController<br>public class UserController {<br> @Autowired<br> private UserRepository userRepository;</pre><pre> @GetMapping(&quot;/api/users&quot;)<br> public List&lt;User&gt; users() {<br> List&lt;User&gt; users = userRepository.findAll();</pre><pre> return users;<br> }<br>}</pre><p>Relancez l’application et vérifiez que l’url répondent bien d’un array vide en json:</p><pre>$ curl &quot;http://localhost:8080/api/users&quot;<br>[]</pre><p>Ajoutez une méthode à notre contrôleur pour ajouter un utilisateur:</p><pre> @PostMapping(&quot;/api/users&quot;)<br> @ResponseStatus(HttpStatus.CREATED)<br> public User addUser(@RequestBody User user) {<br>   userRepository.save(user);</pre><pre>   return user;<br> }</pre><p>Vous ajoutez un utilisateur en curl avec cette commande par exemple:</p><pre>$ curl -d &#39;{&quot;username&quot;: &quot;maxime&quot;, &quot;firstname&quot;: &quot;Maxime&quot;,&quot;lastname&quot;: &quot;Vanmeerbeck&quot;, &quot;email&quot;: &quot;maxime@theblockchain-group.com&quot;}&#39; -H &quot;Content-Type: application/json&quot; -X POST &quot;http://localhost:8080/api/users&quot;</pre><p>Il est souhaitable d’utiliser des outils comme Talend API Tester ou Postman simplifiant grandement l’utilisation des APIs.<br>Si vous avez besoin de supprimer la base MongoDB, il vous faut détruire les volumes du conteneur mongo avec l’option -v:</p><pre>docker-compose down -v</pre><p>Ajoutez quelques utilisateurs et accédez à la liste des utilisateurs:</p><pre>[<br> {<br> &quot;id&quot;:&quot;5daefb17cc403a2d15524ef1&quot;,<br> &quot;username&quot;:&quot;maxime&quot;,<br> &quot;firstname&quot;:&quot;Maxime&quot;,<br> &quot;lastname&quot;:&quot;Vanmeerbeck&quot;,<br> &quot;email&quot;:&quot;maxime@theblockchain-group.com&quot;<br> },<br> {<br> &quot;id&quot;:&quot;5daefb2fcc403a2d15524ef2&quot;,<br> &quot;username&quot;:&quot;soheil&quot;,<br> &quot;firstname&quot;:&quot;Soheil&quot;,<br> &quot;lastname&quot;:&quot;SK&quot;,<br> &quot;email&quot;:&quot;soheil@theblockchain-group.com&quot;<br> },<br> {<br> &quot;id&quot;:&quot;5daefb44cc403a2d15524ef3&quot;,<br> &quot;username&quot;:&quot;lia&quot;,<br> &quot;firstname&quot;:&quot;Lia&quot;,<br> &quot;lastname&quot;:&quot;Almeida&quot;,<br> &quot;email&quot;:&quot;lia@theblockchain-group.com&quot;<br> }<br>]</pre><p>N’oubliez pas de commit et pousser les modifications vers GitLab.<br>Voilà, notre API est prête! La prochaine étape consiste à paramétrer notre application et GitLab pour l’intégration continue.</p><h3>Intégration continue</h3><h3>Les tests</h3><p>Afin d’assurer le bon fonctionnement de l’application, il est préférable de la tester programmatiquement grâce aux tests unitaires. Ajoutez deux tests simples pour vérifier que l’API fonctionne:</p><pre>package xdev;</pre><pre>import com.fasterxml.jackson.databind.ObjectMapper;<br>import org.junit.Test;<br>import org.junit.runner.RunWith;<br>import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;<br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.boot.test.mock.mockito.MockBean;<br>import org.springframework.http.MediaType;<br>import org.springframework.test.context.junit4.SpringRunner;<br>import org.springframework.test.web.servlet.MockMvc;<br>import xdev.controller.UserController;<br>import xdev.model.User;<br>import xdev.repository.UserRepository;</pre><pre>import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;<br>import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;<br>import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;</pre><pre>import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;</pre><pre>@RunWith(SpringRunner.class)<br>@WebMvcTest(UserController.class)<br>public class ApplicationTests {</pre><pre> @Autowired<br> private MockMvc mockMvc;</pre><pre> @MockBean<br> private UserRepository userRepository;</pre><pre> @Test<br> public void usersResponse() throws Exception {<br> this.mockMvc.perform(get(&quot;/api/users&quot;))<br> .andDo(print()).andExpect(status().isOk())<br> .andExpect(content().json(&quot;[]&quot;));<br> }<br></pre><pre> @Test<br> public void addUserResponse() throws Exception {<br> User user = new User(&quot;maxime&quot;, &quot;Maxime&quot;, &quot;Vanmeerbeck&quot;, &quot;maxime@theblockchain-group.com&quot;);</pre><pre> this.mockMvc.perform(post(&quot;/api/users&quot;)<br> .content(new ObjectMapper().writeValueAsString(user))<br> .contentType(MediaType.APPLICATION_JSON)<br> .accept(MediaType.APPLICATION_JSON))<br> .andExpect(status().isCreated());<br> }<br>}</pre><p>Le premier test vérifie que la réponse à l’appel http en GET renvoie bien un array vide en json tandis que le second test vérifie que le statut http de la réponse est bien 201 sur une requête POST.</p><p>Pour lancer les tests, il suffit de jouer la commande</p><pre>./mvnw test</pre><p>L’application est prête à être testée, l’idée est maintenant d’automatiser ces tests sur GitLab.</p><h3>L’intégration sur GitLab</h3><p>GitLab dispose d’un système de pipelines permettant de définir des étapes et lancer les commandes que l’on souhaite. Nous allons créer une pipeline contenant trois étapes:</p><ul><li>pour tester</li><li>pour construire l’image</li><li>et pour déployer</li></ul><p>Pour activer la pipeline, il faut créer un fichier gitlab-ci.yml à la racine du projet. Commençez par l’étape de test. GitLab utilise Docker en interne, le format est similaire à celui de Docker Compose.</p><p>Ajoutez une étape test pendant laquelle on exécute la commande qui lance les tests de l’application Spring Boot.</p><pre>image: openjdk:8-jdk-alpine</pre><pre>services:<br>  - mongo:latest</pre><pre>variables:</pre><pre>stages:<br>  - test</pre><pre>test:<br> stage: test<br> script:<br>   - ./mvnw test</pre><p>Une fois commit et poussé sur le dépôt GitLab, rendez-vous sur la page GitLab du projet. Dans le menu CI/CD, cliquez sur Pipelines, vous verrez que GitLab a automatiquement déclenché la pipeline et est en train de tester l’application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TYBLKcvhmwibM7FP" /></figure><p>Vous pouvez consulter la sortie des logs en cliquant sur les stages. Si les tests échouent, la pipeline s’arrête à cette étape. Si les tests passent, vous pouvons passer à l’étape suivante: le build.</p><p>Pour le build, vous ajoutez une étape build au fichier gitlab-ci.yml ainsi que trois commandes pour s’authentifier sur GitLab, construire l’image de votre application et pousser l’image dans le registre privé de GitLab. L’enregistrement dans le registre vous permettra plus tard au moment du déploiement de récupérer l’image depuis le cloud.</p><pre>build:<br> stage: build<br> image: docker:stable<br> services:<br>   - docker:dind<br> script:<br>   - docker login -u $CI_REGISTRY_USER -p $CI_JOB_TOKEN $CI_REGISTRY<br>   - docker build -t $CI_REGISTRY_IMAGE:latest .<br>   - docker push $CI_REGISTRY_IMAGE:latest</pre><p>Une fois les modifications poussées, vous aurez cette fois deux étapes dans la pipeline:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rgKdsAL4I6K3QeGb" /></figure><p>Une fois le build terminé, l’image de notre application est enregistrée dans le registre de GitLab que vous pouvez consulter dans le menu Packages &gt; Container Registry</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bDb_bmeITjamV4IG" /></figure><h3>Déploiement en production</h3><p>La dernière étape du cycle de vie de notre application est de déployer l’application sur un serveur. Pour cet exercice, nous utiliserons les services de Docker Swarm pour déployer les conteneurs sur Google Cloud. Docker Swarm permet d’orchestrer des clusters de conteneurs Docker.<br>Nous verrons comment configurer Google Cloud pour héberger l’application. Nous installerons d’abord Docker Swarm en local pour déployer la stack sur le cloud. Enfin, il s’agira d’appliquer cette configuration sur GitLab pour obtenir un déploiement continu.</p><h3>Google Cloud</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3l4dutg1_heEge3AIxAXXQ.jpeg" /><figcaption>Embrassez le cloud!</figcaption></figure><p>La première tâche à effectuer est d’ouvrir un compte sur Google Cloud Platform (GCP). GCP offre un crédit vous permettant de tester, en revanche il est nécessaire de compléter les informations de facturation.</p><p><a href="https://cloud.google.com/">https://cloud.google.com/</a></p><p>GCP propose un outil en ligne de commande pour gérer votre stack depuis un terminal. Je vous renvoie vers la page d’installation de gcloud, pour debian et ubuntu par exemple:</p><p><a href="https://cloud.google.com/sdk/docs/quickstart-debian-ubuntu?hl=fr">https://cloud.google.com/sdk/docs/quickstart-debian-ubuntu?hl=fr</a></p><pre>$ gcloud -v<br>Google Cloud SDK 271.0.0<br>alpha 2019.11.08<br>beta 2019.11.08<br>bq 2.0.50<br>core 2019.11.08<br>gsutil 4.46<br>kubectl 2019.11.08</pre><p>Ensuite, identifiez-vous sur GCP avec gcloud:</p><pre>gcloud auth login</pre><p>Cliquez sur le lien et choisissez le même compte google que celui avec lequel vous avez ouvert votre compte GCP. Pour définir les droits par défaut de l’application, utilisez cette commande et de la même manière, autorisez votre compte google:</p><pre>gcloud auth application-default login</pre><p>Créez un projet “spring-boot-from-dev-to-prod” sur GCP</p><pre>gcloud projects create spring-boot-from-dev-to-prod</pre><p>Afin d’héberger l’application, créez une machine virtuelle avec le service compute engine de GCP.<br>D’abord, placez vous sur le projet dernièrement créé:</p><pre>gcloud config set project spring-boot-from-dev-to-prod</pre><p>Et activez le service Compute Engine. Attention, celui-ci nécessite d’activer la facturation sur le compte GCP:</p><pre>gcloud services enable compute.googleapis.com</pre><p>Afin de pouvoir utiliser la machine virtuelle (VM) avec Docker Swarm, il est indispensable de créer la VM avec l’outil docker-machine. Docker Machine embarque un driver pour GCP permettant de créer la machine utilisée par Docker sur GCP.</p><p><a href="https://docs.docker.com/machine/drivers/gce/">https://docs.docker.com/machine/drivers/gce/</a></p><pre>docker-machine create --driver google --google-project spring-boot-from-dev-to-prod vm01</pre><p>Cette commande va créer la VM, installer Docker Machine sur la VM, et vous aurez accès depuis votre terminal local à la docker machine:</p><pre>$ docker-machine ls<br>vm01 - google Running tcp://34.69.221.119:2376 v19.03.5</pre><p>La commande suivante vous permet de voir les propriétés de la machine docker:</p><pre>$ docker-machine env vm01<br>export DOCKER_TLS_VERIFY=”1&quot;<br>export DOCKER_HOST=”tcp://34.69.221.119:2376&quot;<br>export DOCKER_CERT_PATH=”/home/mvanmeerbeck/.docker/machine/machines/vm01&quot;<br>export DOCKER_MACHINE_NAME=”vm01&quot;<br># Run this command to configure your shell: <br># eval $(docker-machine env vm01)</pre><p>L’intérêt étant de pouvoir jouer les commandes docker directement en local, en notifiant à docker grâce à ces variables d’environnements de se connecter au docker de la VM de GCP. Les certificats nécessaires pour se connecter sur la VM sont stockées en local (variable DOCKER_CERT_PATH).<br>Donc, connectez votre docker sur la VM grâce à la commande d’évaluation permet d’exporter les variables d’environnements:</p><pre>eval $(docker-machine env vm01)</pre><p>A partir de ce moment, toutes les commandes docker s’appliqueront sur le docker de la VM. Ainsi, si vous demandez à docker de vous lister les conteneurs en fonctionnement, Docker vous renverra les conteneurs tournant sur la VM uniquement et seulement dans ce terminal. Il faut rejouer l’évaluation sur chaque nouveau terminal.</p><pre>$ docker ps<br>CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES</pre><h3>Initialisation du cluster avec Docker Swarm</h3><p>La VM, l’application et docker sont prêts. Vous allez maintenant déployer l’application sur la VM avec Docker Swarm.<br>Initialisez d’abord Docker Swarm sur le docker de la VM. Pour cela, vous devez renseigner l’IP locale sur le réseau GCP de la VM. Pour trouver cette IP, il suffit de récupérer le champ INTERNAL_IP en listant les VM avec:</p><pre>$ gcloud compute instances list<br>NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS<br>vm01 us-central1-a n1-standard-1 10.128.0.2 34.69.221.119 RUNNING</pre><p>Il est important de passer l’IP locale, autrement les communications sortiront du réseau GCP et passeront par internet. Vous pouvez maintenant initialiser le swarm avec (évaluation faite):</p><pre>docker swarm init --advertise-addr 10.128.0.2:2376</pre><p>Pour ce projet, je n’utilise qu’une seule VM mais il est possible grâce à Docker Swarm (et c’est tout l’intérêt) de passer à l’échelle en déployant l’application sur de multiples VMs. Il faut alors que chaque VM rejoigne le swarm grâce au token donné à l’initialisation.</p><h3>Déploiement</h3><p>Le déploiement de l’application sur la VM via Docker Swarm nécessite l’accès aux images Docker des conteneurs de l’application. Vous pourriez construire directement les images sur le docker de la VM mais il est plus judicieux d’utiliser le registre de GitLab pour héberger les images.</p><p>Etant donné que nous avons déjà construit les images dans le registre de GitLab, il nous suffit de s’identifier sur le registre de GitLab:</p><pre>docker login registry.gitlab.com</pre><p>Docker Swarm utilise le fichier docker-compose.yml pour connaître les conteneurs à déployer sur la VM. En revanche, il faut préciser à Docker Swarm d’utiliser l’image du conteneur spring-boot hébergé sur le registre de GitLab. Le tag de l’image docker est récupérable sur GitLab à cette adresse, et doit être spécifié comme nom de l’image dans le docker-compose.yml.</p><p><a href="https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod/container_registry">https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod/container_registry</a></p><pre>spring-boot:<br>  image: registry.gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod:latest<br>  build: .<br>  restart: always<br>  ports:<br>    - 8080:8080<br>  depends_on:<br>    - mongo</pre><p>Il ne nous reste qu’à déployer la stack avec Docker Swarm en passant le fichier docker-compose.yml en argument:</p><pre>$ docker stack deploy -c docker-compose.yml spring-boot-from-dev-to-prod<br>Ignoring unsupported options: build, restart</pre><pre>Creating network spring-boot-from-dev-to-prod_default<br>Creating service spring-boot-from-dev-to-prod_spring-boot<br>Creating service spring-boot-from-dev-to-prod_mongo</pre><p>Vérifiez l’état des services avec la commande ps:</p><pre>$ docker stack ps spring-boot-from-dev-to-prod<br>ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS<br>sxh5bfv516q3 spring-boot-from-dev-to-prod_mongo.1 mongo:latest vm01 Running Running 1 second ago <br>3jo494n0xsc3 spring-boot-from-dev-to-prod_spring-boot.1 registry.gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod:latest vm01 Running Running 2 seconds ago</pre><p>En cas d’erreur, il est pratique d’utiliser l’option no-trunc pour ne pas tronquer le message d’erreur:</p><pre>docker stack ps --no-trunc spring-boot-from-dev-to-prod</pre><p>La consultation des logs se fait par service avec la commande:</p><pre>docker service logs -f spring-boot-from-dev-to-prod_spring-boot</pre><p>GCP ferme par défaut l’accès à tous les ports. Afin d’autoriser l’accès au port 8080 de l’application Spring Boot, vous devez créer une règle de pare-feu via gcloud:</p><pre>$ gcloud compute firewall-rules create spring-boot --allow tcp:8080<br>Creating firewall…⠏Created [https://www.googleapis.com/compute/v1/projects/spring-boot-from-dev-to-prod/global/firewalls/spring-boot]. <br>Creating firewall…done. <br>NAME NETWORK DIRECTION PRIORITY ALLOW DENY DISABLED<br>spring-boot default INGRESS 1000 tcp:8080 False</pre><p>Tout est prêt! Essayez d’accéder à l’api (mais changez l’IP):</p><p><a href="http://34.69.221.119:8080/api/users">http://34.69.221.119:8080/api/users</a></p><h3>Déploiement continu sur GitLab</h3><p>Vous êtes parvenu à déployer sur GCP manuellement. Cependant, pour mettre en place un déploiement continu de notre application, vous allez reproduire le déploiement via Docker Swarm mais sur GitLab grâce aux pipelines.<br>Lorsque vous avez créé la VM sur GCP via Docker Machine, Docker a créé des certificats nécessaires pour se connecter à la VM.<br>GitLab a besoin de ces informations afin d’accéder au Docker Swarm sur GCP, notamment:</p><ul><li>l’url d’accès au master du swarm</li></ul><p>Celle-ci est visible avec Docker Machine:</p><pre>$ docker-machine ls<br>NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS <br>vm01 * google Running tcp://34.69.221.119:2376 v19.03.5</pre><ul><li>le certificat de l’autorité de certification (ca.pem) situé dans votre home</li></ul><pre>cat ~/.docker/machine/machines/vm01/ca.pem</pre><ul><li>le certificat et la clé privée de la machine locale qui a créé la VM également situé dans votre home</li></ul><pre>cat ~/.docker/machine/machines/vm01/cert.pem<br>cat ~/.docker/machine/machines/vm01/key.pem</pre><p>Grâce aux variables d’environnements de GitLab, vous pouvez secrètement passer ces informations à la CI. Dans les paramètres CI/CD du projet <a href="https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod/-/settings/ci_cd">https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod/-/settings/ci_cd</a>, créez quatre variables:</p><ul><li>DOCKER_SWARM_MASTER avec comme valeur tcp://34.69.221.119:2376 dans mon example</li><li>DOCKER_MACHINE_CA avec comme valeur le contenu du fichier ca.pem</li><li>DOCKER_MACHINE_CLIENT_CERT avec comme valeur le contenu du fichier cert.pem</li><li>DOCKER_MACHINE_CLIENT_KEY avec comme valeur le contenu du fichier key.pem</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9xTkwMvdF2px5WBv" /></figure><p>De plus, pour s’identifier au registre de GitLab, vous devez utiliser un token de déploiement (et pas notre utilisateur GitLab) avec seulement les droits de lecture sur le registre. Rendez-vous sur la page des paramètres du dépôt et ajoutez un token de déploiement en cochant read_registry:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4erLAbwILclRIw-Q" /></figure><p>Maintenant, vous pouvez ajouter une étape de déploiement à notre pipeline CI dans le fichier gitlab-ci.yml:</p><pre>stages: # les trois étapes de notre pipeline<br>  - test<br>  - build<br>  - deploy</pre><p>Et un job de déploiement qui va d’abord s’identifier sur le registre de GitLab, exporter les variables d’environnements pour se connecter au Docker Swarm sur la VM hébergée sur GCP, puis déployer:</p><pre>deploy:<br> stage: deploy<br> image: docker:stable<br> services:<br>   - docker:dind<br> script:<br>   - docker login -u $CI_DEPLOY_USER -p $CI_DEPLOY_PASSWORD $CI_REGISTRY<br>   - export DOCKER_TLS_VERIFY=”1&quot;<br>   - export DOCKER_HOST=”$DOCKER_SWARM_MASTER”<br>   - export DOCKER_CERT_PATH=”certs”<br>   - mkdir $DOCKER_CERT_PATH<br>   - echo “$DOCKER_MACHINE_CA” &gt; $DOCKER_CERT_PATH/ca.pem<br>   - echo “$DOCKER_MACHINE_CLIENT_CERT” &gt; $DOCKER_CERT_PATH/cert.pem<br>   - echo “$DOCKER_MACHINE_CLIENT_KEY” &gt; $DOCKER_CERT_PATH/key.pem<br>   - docker stack deploy -c docker-compose.yml --with-registry-auth spring-boot-from-dev-to-prod<br>   - rm -rf $DOCKER_CERT_PATH</pre><p>Après un push avec git, la pipeline déclenche les tests, le build puis le déploiement sur GCP via Docker Swarm.</p><p><strong>Questions ? Erreurs ? N’hésitez pas à commenter et applaudir si vous appréciez!</strong></p><p>Le code source du projet est disponible sur GitLab<br><a href="https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod">https://gitlab.com/maximevanmeerbeck/spring-boot-from-dev-to-prod</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=584daccfb813" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-blockchain-xdev/de-lenvironnement-de-d%C3%A9veloppement-%C3%A0-la-production-avec-docker-swarm-gitlab-et-google-cloud-584daccfb813">De l’environnement de développement à la production avec Docker Swarm, GitLab et Google Cloud</a> was originally published in <a href="https://medium.com/the-blockchain-xdev">The Blockchain Xdev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>