Linux things 🐧

un blog sur les technologies des logiciels libres et autres digressions

beego caddy docker

Tue, 07 Feb 2017 00:00:00 +0100
# beego   # caddy   # golang   # docker  

Voici un nouvel article sur Docker qui fait suite Ă  docker et macos. Cette fois-ci un usage rĂ©el, avec le dĂ©veloppement d’un simple site web statique dĂ©ployĂ© dans un conteneur docker et publiĂ© par le serveur web caddy. J’utilise un poste de travail sous Linux/Fedora avec les packages golang et docker de la distribution.

Beego

Beego est un framework web en Golang. Golang est un langage que j’apprĂ©cie Ă©normement, il fera peut ĂȘtre l’objet d’un article mais on peut le rĂ©sumer en ces quelques termes : compilĂ©, statique (binaire non dynamique), multiplateforme (windows,mac,linux), multiarchitecture (X86, ARM) , trĂšs performant, simple, efficace, concurrent ; go by example donne des exemples du langage et pour des exemples web https://gowebexamples.github.io/

CrĂ©Ă© par Google en opensource, il a Ă©tĂ© pensĂ© et conçu pour la programmation systĂšme, c’est Ă  dire pour le dĂ©veloppement de services cĂŽtĂ© serveur type serveur web, mais est aussi utilisĂ© sur des systĂšmes embarquĂ©s type rasberry pi et IOT (https://gobot.io)

Golang founi de base le package net/http ainsi que le package html/template qui permettent en quelques lignes de code de dĂ©velopper un serveur web. MĂȘme s’ils suffisent pour un site web basique, certains ont dĂ©veloppĂ©s des frameworks trĂšs complets afin de se rapprocher de ce qui se fait de mieux dans d’autres langages comme python, php ou ruby.

Revel par exemple est trĂšs proche de la phylosophie de Rails en ruby. D’autres framework comme Gorilla prĂ©fĂšrent proposer des boites Ă  outils plutĂŽt qu’un framework complet mais rigide. Le dernier Ă  la mode est Echo , trĂšs minimaliste et rapide.

Pour ma part j’ai pour le moment choisi Beego un framework MVC qui inclut de nombreux outils (gĂ©nĂ©ration d’un squelette, ORM, pagination, API documentation, …).

Installation

go get github.com/astaxie/beego
go get github.com/beego/bee

Un binaire bee a été créé dans $GOPATH/bin/. Si ce chemin a été ajouté dans la variable $PATH, on peut le lancer :

	➜  bee
	Bee is a Fast and Flexible tool for managing your Beego Web Application.

	USAGE
	    bee command [arguments]

	AVAILABLE COMMANDS

	    new         Creates a Beego application
	    run         Run the application by starting a local development server
	    pack        Compresses a Beego application into a single file
	    api         Creates a Beego API application
	    hprose      Creates an RPC application based on Hprose and Beego frameworks
	    bale        Transforms non-Go files to Go source files
	    version     Prints the current Bee version
	    generate    Source code generator
	    migrate     Runs database migrations
	    fix         Fixes your application by making it compatible with newer versions of Beego

	Use bee help [command] for more information about a command.

	ADDITIONAL HELP TOPICS


	Use bee help [topic] for more information about that topic.

DĂ©veloppement

on se positionne dans $GOPATH/src

	➜  cd $GOPATH/src
	➜  bee new test_bee
	______
	| ___ \
	| |_/ /  ___   ___
	| ___ \ / _ \ / _ \
	| |_/ /|  __/|  __/
	\____/  \___| \___| v1.6.2
	2017/02/06 00:14:05 INFO     ▶ 0001 Creating application...
		create	 /home/fredix/Sync/code/golang/src/test_bee/
		create	 /home/fredix/Sync/code/golang/src/test_bee/conf/
		create	 /home/fredix/Sync/code/golang/src/test_bee/controllers/
		create	 /home/fredix/Sync/code/golang/src/test_bee/models/
		create	 /home/fredix/Sync/code/golang/src/test_bee/routers/
		create	 /home/fredix/Sync/code/golang/src/test_bee/tests/
		create	 /home/fredix/Sync/code/golang/src/test_bee/static/
		create	 /home/fredix/Sync/code/golang/src/test_bee/static/js/
		create	 /home/fredix/Sync/code/golang/src/test_bee/static/css/
		create	 /home/fredix/Sync/code/golang/src/test_bee/static/img/
		create	 /home/fredix/Sync/code/golang/src/test_bee/views/
		create	 /home/fredix/Sync/code/golang/src/test_bee/conf/app.conf
		create	 /home/fredix/Sync/code/golang/src/test_bee/controllers/default.go
		create	 /home/fredix/Sync/code/golang/src/test_bee/views/index.tpl
		create	 /home/fredix/Sync/code/golang/src/test_bee/routers/router.go
		create	 /home/fredix/Sync/code/golang/src/test_bee/tests/default_test.go
		create	 /home/fredix/Sync/code/golang/src/test_bee/main.go
	2017/02/06 00:14:05 SUCCESS  ▶ 0002 New application successfully created!

Un squelette de code a été généré, on peut immédiatement tester :

	➜  bee run    
	______
	| ___ \
	| |_/ /  ___   ___
	| ___ \ / _ \ / _ \
	| |_/ /|  __/|  __/
	\____/  \___| \___| v1.6.2
	2017/02/06 00:15:30 INFO     ▶ 0001 Using 'test_bee' as 'appname'
	2017/02/06 00:15:30 INFO     ▶ 0002 Loading default configuration...
	2017/02/06 00:15:30 INFO     ▶ 0003 Initializing watcher...
	2017/02/06 00:15:30 INFO     ▶ 0004 Watching: /home/fredix/Sync/code/golang/src/test_bee/controllers
	2017/02/06 00:15:30 INFO     ▶ 0005 Watching: /home/fredix/Sync/code/golang/src/test_bee
	2017/02/06 00:15:30 INFO     ▶ 0006 Watching: /home/fredix/Sync/code/golang/src/test_bee/routers
	2017/02/06 00:15:30 INFO     ▶ 0007 Watching: /home/fredix/Sync/code/golang/src/test_bee/tests
	test_bee/controllers
	test_bee/routers
	test_bee
	2017/02/06 00:15:32 SUCCESS  ▶ 0008 Built Successfully!
	2017/02/06 00:15:32 INFO     ▶ 0009 Restarting 'test_bee'...
	2017/02/06 00:15:32 SUCCESS  ▶ 0010 './test_bee' is running...
	2017/02/06 00:15:32 [I] [asm_amd64.s:2086] http server Running on http://:8080

Il suffit d’ouvrir un navigateur vers http://localhost:8080.

Dans le terminal on constate que chaque accÚs à la page web génÚre un log bien pratique

2017/02/06 00:16:33 [D] [server.go:2202] |      127.0.0.1| 200 |   6.585903ms|   match| GET      /     r:/
2017/02/06 00:17:39 [D] [server.go:2202] |      127.0.0.1| 200 |   5.996408ms|   match| GET      /     r:/

un ctrl/c puis un ls montre que beego a bien généré un binaire test_bee

➜  ls
conf  controllers  main.go  models  routers  static  test_bee  tests  views

il suffit de lancer ce binaire pour relancer le site web

➜  ./test_bee 
2017/02/06 00:21:41 [I] [asm_amd64.s:2086] http server Running on http://:8080

cependant pour dĂ©velopper, il vaut mieux utiliser bee run, en effet Ă  chaque modification/sauvegarde de votre code golang, bee va le dĂ©tecter et recompiler le binaire automatiquement, il n’y a qu’a reloader la page web du navigateur pour tester son nouveau code.

Pour le déploiement en production, il suffi de déployer le binaire et les répertoires views, static et conf. Nul besoin de déployer des centaines de fichiers php,ruby ou python et leurs multiples bibliothÚques.

Docker

Pour “dockeriser” le site, il est nĂ©cessaire de crĂ©er un fichier Dockerfile dans le rĂ©pertoire racine du projet

FROM golang:1.7.4

# Create the directory where the application will reside
RUN mkdir /app

# Copy the application files (needed for production)
ADD test_bee /app/test_bee
ADD views /app/views
ADD static /app/static
ADD conf /app/conf

# Set the working directory to the app directory
WORKDIR /app

# Expose the application on port 8080.
# This should be the same as in the app.conf file
EXPOSE 8080

# Set the entry point of the container to the application executable
ENTRYPOINT /app/test_bee

Ce Dockerfile utilise une image golang basĂ© sur debian et qui contient le compilateur Go. Dans cet exemple il est inutile et n’importe quelle image Linux aurait fait l’affaire. Les directives ADD copient les repertoires et le binaire dans le rĂ©pertoire de travail /app. On expose le service sur le port 8080 du conteneur enfin le point d’entrĂ© est le binaire lui mĂȘme.

On peut ensuite construire l’image docker Ă  partir de ce Dockerfile

➜  sudo docker build -t test_bee .
Sending build context to Docker daemon 11.27 MB
Step 1 : FROM golang:1.7.4
 ---> f3bdc5e851ce
Step 2 : RUN mkdir /app
 ---> Using cache
 ---> 340c95dce984
Step 3 : ADD test_bee /app/test_bee
 ---> 2309a364d30d
Removing intermediate container f81926095aa4
Step 4 : ADD views /app/views
 ---> 6e76c453a59e
Removing intermediate container 53462f22be29
Step 5 : ADD static /app/static
 ---> 0a509d902b81
Removing intermediate container dc17015a69cd
Step 6 : ADD conf /app/conf
 ---> 45ca0bd4797e
Removing intermediate container 5bc68100a7cb
Step 7 : WORKDIR /app
 ---> Running in 04c7d82795c7
 ---> f55cc98abbea
Removing intermediate container 04c7d82795c7
Step 8 : EXPOSE 8080
 ---> Running in bd0d6570f558
 ---> 5bd99ec3e7fe
Removing intermediate container bd0d6570f558
Step 9 : ENTRYPOINT /app/test_bee
 ---> Running in b6ba08bfc8b8
 ---> 379d95270e02
Removing intermediate container b6ba08bfc8b8
Successfully built 379d95270e02

on vérifie la présence de notre nouvelle image

➜  sudo docker images
REPOSITORY                     TAG                 IMAGE ID            CREATED              SIZE
test_bee                       latest              379d95270e02        About a minute ago   685.2 MB

enfin on démarre le conteneur basé sur notre image

➜  sudo docker run -it --rm --name test_bee -p 8080:8080 -v /app/test_bee:/go/src/test_bee -w /go/src/test_bee test_bee
2017/02/06 20:12:32 [I] [asm_amd64.s:2086] http server Running on http://:8080

en allant sur http://localhost:8080/ on consulte la page par dĂ©faut servie par le binaire Golang test_beestockĂ© dans notre conteneur. Simple et rapide mais quel est l’intĂ©ret de lancer notre programme dans un conteneur docker par rapport Ă  la version oĂč on le lance via bee run ?

Pendant le dĂ©veloppement pas grand chose sauf si le programme doit accĂ©der Ă  des services tiers types base de donnĂ©es, serveur clĂ©/valeur (redis, ..) etc. En effet chacun de ces services devra ĂȘtre installĂ© et configurĂ© sur le poste de dĂ©veloppement qui est lui certainement dans une version d’OS diffĂ©rent de la production et avec des paquets en version diffĂ©rente. Or chacun de ces services possĂšdent souvent une image docker qu’il suffira d’installer sur le poste de dĂ©veloppement, ensuite notre image test_bee pourra communiquer avec ces autres instances docker. Cette configuration sera identique en production, ce qui garanti au dĂ©veloppeur un comportement identique de son code en dev et prod. Exemple

docker run --name caddy -p 80:80 -p 443:443 -d -v caddy-data:/etc/ -v caddy-root:/root/.caddy --link gogs:gogs --link hugo --link wallabag --link keeweb abiosoft/caddy:latest

Ceci un docker run sur mon serveur personnel. Cette commande lance le conteneur caddy (un serveur web en Golang) qui est linkĂ© (–link) avec d’autres conteneurs. En effet chaque conteneur (gogs, hugo, wallabag) expose leur service vers un port non exposĂ© sur Internet du serveur physique. Caddy, qui agit comme un proxy web, associe un domaine (fredix.xyz) vers le port 1313 du service web hugo :

docker run --name hugo -d -p 1313 -v hugo-data:/usr/share/blog/ fredix/hugo

GrĂące au -link ,docker relie les interfaces rĂ©seaux les diffĂ©rents conteneurs, ce qui permet au conteneur caddy de communiquer avec le conteneur hugo. Cette configuration peut ĂȘtre totalement exĂ©cutĂ© sur un poste de dĂ©veloppement local et permet ainsi au codeur de valider son code et son architecture telle qu’elle le sera en production.

Revenons Ă  notre simple conteneur test_bee. On est content il tourne en local, mais Ă  prĂ©sent nous souhaitons l’exĂ©cuter en production sur un serveur public. Il est nĂ©cessaire d’envoyer notre image dans un registre qui la stockera et permettra de la tĂ©lĂ©charger Ă  volontĂ©. Le pus simple et rapide est d’utiliser celui fourni par docker https://hub.docker.com/. Il permet de stocker autant de conteneur publique que l’on veut et 1 seul conteneur privĂ© dans la version gratuite.

Pour stocker un blog, un conteneur public fait bien l’affaire. Pour des conteneurs plus ‘corporate’ soit il suffit de payer sur hub.docker.com pour obtenir plus de dĂ©pĂŽt privĂ©, soit de monter sa propre registry.

Une fois son compte crĂ©Ă©, il suffit de s’y connecter depuis son PC local

➜  sudo docker login 
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
Username: fredix
Password: 
Login Succeeded

Avant d’envoyer l’image test_bee sur le registre docker, on modifie le conf/app.conf pour passer l’application en mode prod

➜  cat conf/app.conf 
appname = test_bee
httpport = 8080
runmode = prod

Enfin il faut renommer l’image en la prĂ©fixant par son login, on va donc la recrĂ©er

sudo docker build -t fredix/test_bee .  

On la publie sur le registre

sudo docker push fredix/test_bee                                                                                    
The push refers to a repository [docker.io/fredix/test_bee]
00f90a010461: Pushed 
12f4ee6b1258: Pushed 
1711061d538e: Pushed 
07e64af846fc: Pushed 
63a82295fe41: Mounted from fredix/nodecast.net 
fd3ac0159235: Mounted from fredix/nodecast.net 
784715688dd8: Mounted from fredix/nodecast.net 
7f8e95b7f6d7: Mounted from fredix/nodecast.net 
f4d2be23d596: Mounted from fredix/nodecast.net 
30339f20ced0: Mounted from fredix/nodecast.net 
0eb22bfb707d: Mounted from fredix/nodecast.net 
a2ae92ffcd29: Mounted from fredix/nodecast.net 
latest: digest: sha256:bdac1508df2d2e72c5c51804866646df5a345a5c2cb1fceac586bad117b6f6be size: 2833

Dans un navigateur web on peut consulter la présence de ce nouveau dépÎt ( une fois connecté à https://hub.docker.com/ avec son compte bien entendu).

Cette image publique pourra ĂȘtre tĂ©lĂ©chargĂ© par n’importe-qui, ce qui est le but si vous souhaitez diffuser un de vos logiciels opensource de maniĂšre simple Ă  vos utilisateurs. Ainsi ils n’auront pas besoin d’installer et configurer eux-mĂȘme tous les outils nĂ©cessaires au fonctionnement de votre service. Pour quelque chose de plus personnel comme un blog, il n’y a pas de mal mais pas d’intĂ©rĂȘt pour un tiers Ă  tĂ©lĂ©charger votre image, surtout si celle-ci ne contient qu’un binaire golang donc sans code source comme dans cet exemple.

Cependant il est tout Ă  fait possible que le Dockerfile exĂ©cute un go get ou un git clone de votre code source hĂ©bergĂ© chez github par exemple, le compile (si c’est du go l’image golang a alors tout son intĂ©rĂȘt) puis l’exĂ©cute. C’est d’ailleurs sur ce principe que certains construisent et publient des images docker de logiciel opensource qui n’ont pas d’image docker faites par les dĂ©veloppeurs du projet, ce qui devient des images non officielles.

Connectons nous en ssh sur notre serveur public. On va pouvoir télécharger notre image

docker pull fredix/test_bee

ou l’exĂ©cuter directement ce qui la tĂ©lĂ©chargera si elle n’est pas prĂ©sente en local

docker run --name test_bee -d fredix/test_bee
Unable to find image 'fredix/test_bee:latest' locally
latest: Pulling from fredix/test_bee
5040bd298390: Already exists 
fce5728aad85: Already exists 
76610ec20bf5: Already exists 
86b681f75ff6: Already exists 
8553b52886d8: Already exists 
63c25ee63bd6: Already exists 
4268eec6f44b: Already exists 
d73944078585: Already exists 
6b99d012c4c6: Pull complete 
63b6323c4d21: Pull complete 
c1343e5441f0: Pull complete 
ae4a1f7364db: Pull complete 
Digest: sha256:bdac1508df2d2e72c5c51804866646df5a345a5c2cb1fceac586bad117b6f6be
Status: Downloaded newer image for fredix/test_bee:latest
fd09bb92f2b82d22399aab0ad020820920fd24d55cbfb759bdf86bc8b8860752

L’image et ses layers ont Ă©tĂ© tĂ©lĂ©chargĂ©s, puis elle a Ă©tĂ© aussitĂŽt instanciĂ©.

docker ps
CONTAINER ID        IMAGE                   COMMAND                  CREATED              STATUS              PORTS                                                NAMES
e70b96523cf1        fredix/test_bee         "/bin/sh -c /app/t..."   3 minutes ago        Up 3 minutes        8080/tcp                                             test_bee

On peut vérifier que tout fonctionne on consultant le log

docker logs test_bee
2017/02/06 21:40:07 [I] [asm_amd64.s:2086] http server Running on http://:8080
```	
	
Mais aussi entrer dans le conteneur

```sh
docker exec -it test_bee bash
root@7e4e230fbca3:/app# ps ax
  PID TTY      STAT   TIME COMMAND
    1 ?        Ss     0:00 /bin/sh -c /app/test_bee
    6 ?        Sl     0:00 /app/test_bee
   18 ?        Ss     0:00 bash
   23 ?        R+     0:00 ps ax
root@7e4e230fbca3:/app# exit

Dans le docker run –name test_bee on aurait pu ajouter l’option -P ce qui aurait demandĂ© Ă  docker de mapper le port interne 8080 de l’application beego dans le conteneur vers un port alĂ©atoire de l’hĂŽte. Cela est inutile si le serveur web qui ferra reverse proxy est Ă©galement dans un conteneur docker, s’il est hors de docker, alors vous pourrez vĂ©rifier avec un wget en utilisant le port du hĂŽte relayĂ© par docker vers le port 8080 du conteneur. En effet les ports des services dans les conteneurs ne sont pas accessible hors de ceux-ci, l’option –link de docker run va permettre de les rendre visible Ă  l’extĂ©rieur de docker.

# On suppose que docker avec -P a alloué le port 32772 vers le port 8080 de test_bee
# sur l'hĂŽte on peut alors faire 
wget localhost:32772
--2017-02-06 21:23:59--  http://localhost:32772/
Resolving localhost (localhost)... ::1, 127.0.0.1
Connecting to localhost (localhost)|::1|:32772... connected.
HTTP request sent, awaiting response... 200 OK
Length: 70111 (68K) [text/html]
Saving to: ‘index.html’

index.html                                                  100%[=========================================================================================================================================>]  68.47K  --.-KB/s    in 0s      

2017-02-06 21:23:59 (137 MB/s) - ‘index.html’ saved [70111/70111]

le contenu du index.html doit correspondre Ă  la page d’accueil de test_bee. Il reste maintenant Ă  exposer notre service sur Internet.

Caddy

Caddy est un serveur web en golang, qui en plus d’ĂȘtre simple Ă  configurer a l’obligeance de gĂ©nĂ©rer et tĂ©lĂ©charger automatiquement des certificats Let’s encrypt ( https://caddyserver.com/docs/automatic-https ) . Ainsi chaque domaine configurĂ© dans caddy sera exposĂ© en https et avec un certificat valide \o/ J’ai pour ce test crĂ©Ă© un sous domaine test.fredix.xyz qui renvoit vers l’ip de mon serveur.

Tout d’abord on crĂ©Ă© des volumes dans docker afin de stocker les fichiers de configuration et les certificats de caddy. Cela permettra de supprimer pour mettre Ă  jour l’image caddy sans supprimer ses donnĂ©es. Ce travail est d’ailleurs Ă  faire sur chacun des conteneurs sauf s’ils n’ont pas de donnĂ©es Ă  conserver ce qui est plutĂŽt rare.

docker volume create --name caddy-root 
docker volume create --name caddy-data

on lance le conteneur

docker run --name caddy -p 80:80 -p 443:443 -d -v caddy-data:/etc/ -v caddy-root:/root/.caddy --link test_bee abiosoft/caddy:latest

On expose les ports 80 et 443 vers Internet puisque l’on souhaite qu’il agisse de server web pour nos autres conteneurs. On lui fourni 2 volumes dans lesquels il pourra stocker ses donnĂ©e persistantes (configuration et certificats) puis on le relie au conteneur test_bee afin qu’il puisse accĂšder Ă  son port 8080 pour lui relayer les requetes HTTP en provenance d’Internet.

Entrons dans le conteneur caddy pour constater ce qu’Ă  permis le –link

docker exec -it caddy sh
/srv # cat /etc/hosts
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
ff00::0	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
172.17.0.2	test_bee eb639a77249e
exit

On constate que docker a ajoutĂ© dans le /etc/hosts l’ip et le nom du conteneur test_bee. Cela permet de mettre dans la configuration Caddyfile test_bee qui pourra ĂȘtre rĂ©solu. On peut vĂ©rifier avec un wget

docker exec -it caddy sh
cd /root
wget http://test_bee:8080
Connecting to test_bee:8080 (172.17.0.2:8080)
index.html           100%
cat index.html
exit

on peut Ă©diter ensuite son fichier de configuration depuis le serveur hĂŽte

cat /var/lib/docker/volumes/caddy-data/_data/Caddyfile

	test.fredix.xyz {  
	    proxy / test_bee:8080 {
		header_upstream Host {host}
		header_upstream X-Real-IP {remote}
		header_upstream X-Forwarded-Proto {scheme}
	    }
	    tls fredix@protonmail.com
	}

Ces quelques lignes suffisent pour gĂ©nĂ©rer des certificats associĂ©s Ă  mon email, et pour rediriger les requetes en http/https de test.fredix.xyz vers le conteneur test_bee sur le port 8080. On voit ici l’intĂ©rĂȘt du –link test_bee : Docker autorise ainsi la connexion rĂ©seau entre les 2 conteneurs et nul besoin de connaitre le port affectĂ© par docker sur l’hĂŽte (32772), le nom du conteneur et le port interne suffise.

On peut relancer ensuite le conteneur

docker restart caddy

le log confirme la génération du certificat

docker logs caddy
Activating privacy features...2017/02/06 22:13:08 [INFO][test.fredix.xyz] acme: Obtaining bundled SAN certificate
2017/02/06 22:13:09 [INFO][test.fredix.xyz] acme: Authorization already valid; skipping challenge
2017/02/06 22:13:09 [INFO][test.fredix.xyz] acme: Validations succeeded; requesting certificates
2017/02/06 22:13:09 [INFO] acme: Requesting issuer cert from https://acme-v01.api.letsencrypt.org/acme/issuer-cert
2017/02/06 22:13:10 [INFO][test.fredix.xyz] Server responded with a certificate.
 done.
https://test.fredix.xyz
2017/02/06 22:13:10 https://test.fredix.xyz

que l’on peut trouver dans

ls -al /var/lib/docker/volumes/caddy-root/_data/acme/acme-v01.api.letsencrypt.org/sites/test.fredix.xyz/
total 20
drwx------ 2 root root 4096 Feb  6 22:13 .
drwx------ 8 root root 4096 Feb  6 22:13 ..
-rw------- 1 root root 3444 Feb  6 22:13 test.fredix.xyz.crt
-rw------- 1 root root  225 Feb  6 22:13 test.fredix.xyz.json
-rw------- 1 root root 1679 Feb  6 22:13 test.fredix.xyz.key

On peut à présent vérifier dans un navigateur web que tout fonctionne

caddy

Lorsque le dĂ©veloppeur corrige des bugs, ajoute des fonctionnalitĂ©s, il lui suffira de rebuilder son image, la republier sur le hub.docker.com, lancer un docker pull de celle-ci sur son serveur, stopper et supprimer le conteneur en prod et le relancer. Ces tĂąches sont bien sĂ»r Ă  automatiser avec par exemple ansible, Ă  associer avec des outils d’intĂ©gration continue.

C’Ă©tait un exemple trĂšs basique, vous trouverez un article plus complet du dĂ©ploiement d’une application golang Ă  cette adresse How To Deploy a Go Web Application with Docker