Introduction

Avec l’arrivée de Docker, notre façon de déployer nos applications a changé. Alors que la virtualisation classique impose d’avoir plusieurs OS, Docker se veut bien plus léger car il n’en utilise qu’un dans lequel, il isole chaque application dans un container.

De base Docker a été pensé par des développeurs pour des développeurs, mais son succès en fait aussi un outil précieux pour tous les administrateurs et DevOps.

Le saviez-vous ? Docker est codé en Go.

Quelques liens utiles:

Le but de cet article n’est pas de vous apprendre à utiliser Docker car il y a déjà des ressources sur internet plus spécialisées. Nous aborderons dans ce sujet la façon de déployer un serveur Go avec Docker.

Mise en place

Pour déployer son application avec Go il existe une image golang sur le dépôt officiel de Docker. Nous partirons de cette image de base pour créer la nôtre.

Avant de commencer, il faut coder notre programme. Placez-vous dans votre espace de travail et créez un fichier main.go

package main

import "net/http"

func helloHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("<h1>Hello Docker</h1>"))
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    http.ListenAndServe(":8080", nil)
}

Maintenant nous allons créer une image avec Docker pour notre application. Pour y parvenir nous utiliserons un fichier nommé Dockerfile. À l’intérieur de ce fichier il faut définir où se trouve les sources du code, comment compiler et le point d’entrée du container afin de rendre disponible notre application.

Toujours dans le répertoire de votre projet, créez un fichier Dockerfile (sans extension) :

# Utilisation de golang comme image de base
# Le GOPATH par défaut de cette image est /go.
FROM golang

# Copie des sources de notre projet dans le container,
# dans notre cas le main.go
COPY . /go/src/hello

# Lancement de la compilation avec go install
RUN go install hello

# Définissions du point d'entré de notre programme compilé
ENTRYPOINT /go/bin/hello

# Le port sur lequel notre serveur écoute
EXPOSE 8080

Construction de l’image avec Docker

# Construction de l'image avec comme tag le nom et la version
$ docker image build -t hello:1.0 .

# Lister les images
docker images

# Lancement de l'image
docker container run --name hello -p 8000:8080 -d hello:1.0
fb481a84e13af89d742187c0e30f97fbe078a2261dfaeba484ce2fba094a3e09

# Lister les images en cours d'exécution
docker container ps
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
fb481a84e13a        hello:1.0           "/bin/sh -c /go/bin/"   13 seconds ago      Up 12 seconds       0.0.0.0:8000->8080/tcp   hello

# Pour arrêter l'image
docker container stop hello

# Pour redémarrer l'image
docker container start hello

Ouvrez votre navigateur favoris et entrez une de ses urls ou la vôtre en fonction de votre configuration :

Versionner ses containers

Comme vu plus haut nous avons donné un tag hello:1.0 qui permet à notre image d’avoir un numéro de version. C’est intéressant si une nouvelle mouture doit paraître, de garder l’ancienne en cas de problème et pouvoir faire marche arrière.

Conclusion

Containériser un serveur Go avec Docker est très simple à mettre en œuvre. Il permet en plus d’avoir plusieurs versions que l’on peut démarrer et arrêter en une ligne de commande.

N’hésitez pas à visiter la page de l’image officielle de Go sur Docker.com pour plus d’informations.

Il n'y a pas de commentaires.