Partie 1 :Créer son application Go

Étape 1:

Nous partons du principe que Golang est déjà installé sur votre machine, le tutoriel se déroulera sur un MacBook.

Étape 2:

Commençons par changer de répertoire vers notre GOPATH. Pour trouver votre GOPATH sous Linux, tapez la commande suivante  

env | grep GOPATH 

Par exemple, le mien se trouve dans /home/<mon-nom d'utilisateur>/go/ sur mon MacBook Pro. Voyons ça :

cd $ GOPATH 

Dans ce répertoire, on trouve alors deux dossiers, un dossier bin et un dossier src. Si votre répertoire GOPATH est vide, créez ces deux dossiers. Puis plongez dans le dossier src :

cd src 

Créez un dossier appelé welcome-app et vérifiez-le.  

mkdir welcome-app
cd welcome-app

Votre structure de répertoire devrait ressembler à quelque chose comme ça :

/home
  /<your-username>
    /go
      bin/
         //Empty for now 
      src/
        /welcome-app

Remarque:

(mon répertoire est légèrement différent pour les besoins de la présentation de ce didacticiel, tant que vous créez cette application dans le répertoire go/src, vous devriez être ok)  

~ /go/src/github.com/gabrielsagnard/welcome-app

Étape 3:

Construisez le front-end

Avant de plonger dans le code, configurons rapidement le frontal. Le but de ce didacticiel est de s’assurer que le front-end est le plus simple possible, afin que nous puissions nous concentrer sur le code du serveur Go. Dans la plupart des applications, le code HTML est généralement placé dans un dossier de modèles. Ce n'est pas une obligation, mais cela nous aide à organiser un peu notre code.

//create a template directory in ~/go/src/welcome-app for our html
mkdir template
//create a static/stylesheets directory in ~/go/src/welcome-app for our css
mkdir -p static/stylesheets
//Open's Visual Studio code, you can open any text editor of choice code .


Dans le répertoire template, je crée le fichier welcome-template.html. J'ai également téléchargé une photo de stock de Pexels, mais vous pouvez télécharger une photo depuis n'importe quel autre site gratuit, par exemple. Pikwizard. J'ai ensuite nommé ce fond. Dans le répertoire static/stylesheets, je crée welcome-template.css.

3.1 Html

templates/welcome-template.html
<!DOCTYPE html>

<html>
   <head>
         <meta charset="UTF-8">
         <link rel="stylesheet" href="/static/stylesheets/welcome-template.css">

         <!-- The welcome struct (shown in the main.go code) is received within the HTML and we just need to use the . operator and retrieve the information we want -->
         <title>Welcome {{.Name}}</title>
   </head>
   <body>
      <div class="welcome center">Welcome {{.Name}}, it is {{.Time}}</div>
   </body>
</html>

3.2 CSS

static/stylesheets/welcome-template.css
body  {
   min-height:100%;
   background-image: url("/static/stylesheets/background.jpeg"), linear-gradient(rgba(0,0,0,0.2),rgba(0,0,0,0.3));
   background-blend-mode: overlay;
   background-size:cover
}

.welcome {
   font-family: 'Segoe UI', 'Tahoma', 'Geneva', 'Verdana', 'sans-serif';
   font-size: 3rem;
   color: aliceblue;
}

.center {
   height: 100vh;
    display: flex;
    justify-content: center;
    align-items: center
}​

3.3 Une photo background sympa

background.jpeg | Photo from Pexels | Ylanite Koppens

Étape 4:

Le temps est venu! Implémentons une certaine logique et parlons de ce qu’il faut pour construire un serveur virtuel. J'ai ajouté des explications dans les commentaires. (Une liste de codes est fournie à la fin de l'article pour une meilleure mise en forme).

main.go 
import (
   "net/http"
   "fmt"
   "time"
   "html/template"
)

//Create a struct that holds information to be displayed in our HTML file
type Welcome struct {
   Name string
   Time string
}

//Go application entrypoint
func main() {
   //Instantiate a Welcome struct object and pass in some random information. 
   //We shall get the name of the user as a query parameter from the URL
   welcome := Welcome{"Anonymous", time.Now().Format(time.Stamp)}

   //We tell Go exactly where we can find our html file. We ask Go to parse the html file (Notice
   // the relative path). We wrap it in a call to template.Must() which handles any errors and halts if there are fatal errors

   templates := template.Must(template.ParseFiles("templates/welcome-template.html"))

   //Our HTML comes with CSS that go needs to provide when we run the app. Here we tell go to create
   // a handle that looks in the static directory, go then uses the "/static/" as a url that our
   //html can refer to when looking for our css and other files. 

   http.Handle("/static/", //final url can be anything
      http.StripPrefix("/static/",
         http.FileServer(http.Dir("static")))) //Go looks in the relative "static" directory first using http.FileServer(), then matches it to a
         //url of our choice as shown in http.Handle("/static/"). This url is what we need when referencing our css files
         //once the server begins. Our html code would therefore be <link rel="stylesheet"  href="/static/stylesheet/...">
         //It is important to note the url in http.Handle can be whatever we like, so long as we are consistent.

   //This method takes in the URL path "/" and a function that takes in a response writer, and a http request.
   http.HandleFunc("/" , func(w http.ResponseWriter, r *http.Request) {

      //Takes the name from the URL query e.g ?name=Martin, will set welcome.Name = Martin.
      if name := r.FormValue("name"); name != "" {
         welcome.Name = name;
      }
      //If errors show an internal server error message
      //I also pass the welcome struct to the welcome-template.html file.
      if err := templates.ExecuteTemplate(w, "welcome-template.html", welcome); err != nil {
         http.Error(w, err.Error(), http.StatusInternalServerError)
      }
   })

   //Start the web server, set the port to listen to 8080. Without a path it assumes localhost
   //Print any errors from starting the webserver using fmt
   fmt.Println("Listening");
   fmt.Println(http.ListenAndServe(":8080", nil));
}

Étape 5:

Exécutez notre application.

Nous avons tout ce dont nous avons besoin pour que notre application s'exécute. Vérifiez dans le chemin du projet et dans le type de terminal.

go run main.go 

Le serveur démarrera sur le port 8080. Accédez à localhost:8080 sur votre navigateur Web.

Pour afficher votre nom, tapez? Name = your-name-here. Voilà, une application web entièrement fonctionnelle! Si vous voulez le repository entier, clonez-le ici

Dans ce tutoriel, nous avons créé une application Web Go simple qui nous a accueillis et nous a donné la date et l'heure. Nous avons expliqué comment utiliser des parties de la bibliothèque net/http pour servir les deux modèles ainsi que des fichiers supplémentaires pour un itinéraire particulier. Maintenant attaquons-nous à la containeurisation de notre application avec Docker.

Partie 2 : Dockeriser notre application Go

Désormais l'objectif est pour nous de permettre la conteneurisation notre application et de la déployer sur le service Kubernetes géré par Google appelé Google Kubernetes Engine (GKE). GKE, comme nous allons le voir permet de gérer et orchestrer les conteneurs Docker pour assurer une haute disponibilité de notre application. Il se situe en quelque sorte entre GAE et GCE en ce qui concerne la manière dont il est mis en pratique. Mais avant d'y arriver, nous devons en apprendre davantage sur la conteneurisation.  Nous allons utiliser Docker pour packager notre application Go créée dans la première partie de l'article et créer une image que Docker pourra utiliser sur tout système pouvant héberger des conteneurs, tels que GKE.

Pré-requis :

  • Il vous faut Docker installé sur votre MacBook ou autre machine évidemment.

Étape 1:

Dans le répertoire welcome-app, créez un fichier nommé Dockerfile (notez qu'il ne nécessite aucune extension, par exemple txt, yml, yaml, etc.). Copiez le contenu du fichier ci-dessous.

#/welcome-app/Dockerfile
FROM "golang:alpine"
# Here the FROM clause states which base image we are intending to work with. If the image does not exist, locally, Docker automatically fetches it from Dockerhub. If you supplied a URI for the image, Docker will download it from there too. Here we begin with the golang:alpine image
MAINTAINER "Martin Ombura <info@martinomburajr.com>"
# Shows who created/maintains the file
WORKDIR /go/src
# Tells Docker to create a working directory that the container will by default use for your project. When you docker -ti <image> it will check into this folder first
COPY . /go/src
# This command tells Docker to copy files from our local machine, into the container that is being built. In some cases we can choose to download our code from Github or any other source, for our case it is simple enough to just COPY the welcome-app to Docker. and place it in the WORKDIR mentioned earlier.
RUN cd /go/src && go build -o main
# Check into our working directory, build our main.go
EXPOSE 8080
# This tells Docker to expose a certain port that can be listened to. This is important since our application is exposing on Port 8080, we need Docker to also expose on this port so that external sources can interact with our app.
ENTRYPOINT "./main"
# This is the first command to run once the container starts, turning it into an automatically running welcome-app server.

Étape 2: Construire notre image

Nous pouvons exécuter le fichier Dockerfile à l'aide de la commande suivante :

docker build -t welcome-app:1.1 .

    MBP-de-admin:welcome-app admin$ docker build -t welcome-app .
Sending build context to Docker daemon  3.649MB
Step 1/12 : FROM golang:alpine AS build-env
alpine: Pulling from library/golang
4fe2ade4980c: Already exists 
2e793f0ebe8a: Pull complete 
77995fba1918: Pull complete 
cacfaec3bb6b: Pull complete 
885a921d7cd2: Pull complete 
Digest: sha256:692eff58ac23cafc7cb099793feb00406146d187cd3ba0226809317952a9cf37
Status: Downloaded newer image for golang:alpine
 ---> 57915f96905a
Step 2/12 : WORKDIR /go/src
 ---> Running in 6903ae31b3d5
Removing intermediate container 6903ae31b3d5
 ---> 4822cf8bd2ff
Step 3/12 : COPY . /go/src/welcome-app
 ---> 93b491212d77
Step 4/12 : RUN cd /go/src/welcome-app && go build .
 ---> Running in 0f33aa06566e
Removing intermediate container 0f33aa06566e
 ---> 90db33b39f0b
Step 5/12 : FROM alpine
latest: Pulling from library/alpine
4fe2ade4980c: Already exists 
Digest: sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528
Status: Downloaded newer image for alpine:latest
 ---> 196d12cf6ab1
Step 6/12 : RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk*
 ---> Running in b4a3ea3c2e51
fetch http://dl-cdn.alpinelinux.org/alpine/v3.8/main/x86_64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.8/community/x86_64/APKINDEX.tar.gz
v3.8.1-85-g6dd49eeff4 [http://dl-cdn.alpinelinux.org/alpine/v3.8/main]
v3.8.1-82-gde46139a22 [http://dl-cdn.alpinelinux.org/alpine/v3.8/community]
OK: 9546 distinct packages available
(1/1) Installing ca-certificates (20171114-r3)
Executing busybox-1.28.4-r1.trigger
Executing ca-certificates-20171114-r3.trigger
OK: 5 MiB in 14 packages
Removing intermediate container b4a3ea3c2e51
 ---> 9a4c99cde148
Step 7/12 : WORKDIR /app
 ---> Running in ce2662ff84b5
Removing intermediate container ce2662ff84b5
 ---> 88c2e3f5cdfb
Step 8/12 : COPY --from=build-env /go/src/welcome-app/welcome-app /app
 ---> f88b14e009d3
Step 9/12 : COPY --from=build-env /go/src/welcome-app/templates /app/templates
 ---> 140fbb5371a6
Step 10/12 : COPY --from=build-env /go/src/welcome-app/static /app/static
 ---> 7f3636199add
Step 11/12 : EXPOSE 8080
 ---> Running in d48d436c02a2
Removing intermediate container d48d436c02a2
 ---> f20397b23709
Step 12/12 : ENTRYPOINT [ "./welcome-app" ]
 ---> Running in 250800b765c3
Removing intermediate container 250800b765c3
 ---> b6953870f9fa
Successfully built b6953870f9fa
Successfully tagged welcome-app:latest

Notez la taille de nos conteneurs, ils sont assez grands. Dans la prochaine, nous allons trouver un moyen de les réduire à 3,5% de leur taille actuelle.

Étape 3: Testez notre image

Avec la construction de l'image, nous pouvons l'exécuter et voir ce qu'elle génère

docker run -ti welcome-app:1.1

Ouvrez votre navigateur local et tapez localhost:8080 dans votre barre d’URL.

Étape 4 :

En quelques mots, le processus à plusieurs étapes nous permet d’utiliser deux images distinctes. La première image est utilisée pour créer nos fichiers binaires d’application à l’aide de l’outil Go et de tout le reste qui ajoute au poids du conteneur. Une fois construit, ce binaire peut maintenant être compris de manière native par la plupart des conteneurs Linux sans avoir besoin d'outils / compilateurs et autres outils inutiles. Nous prenons ce fichier binaire et le copions dans une nouvelle image de base telle que Alpine, qui fait environ 4,15 Mo (ridiculement minuscule). Le binaire lui-même est également à peu près 6MBs (dépend de votre application). Nous ajoutons ensuite quelques certificats de CA pour nous assurer que notre image dispose des outils nécessaires pour communiquer avec d'autres serveurs SSL sur Internet. Nous prenons enfin cette nouvelle image fraîche qui a notre binaire, et exécutons notre binaire au démarrage d’image et voilà. Une nouvelle application légère prête à être servie.  Voici le nouveau fichier Dockerfile

FROM golang:alpine AS build-env
#Here we give the image a variable name that we can refer to later, we call it build-env
WORKDIR /go/src
ADD . /go/src/welcome-app
RUN cd /go/src/welcome-app && go build -o main
#go build command creates a linux binary that can run without any go tooling.
FROM alpine
#Alpine is one of the lightest linux containers out there, only a few 4.15MB
RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk*
WORKDIR /app
COPY --from=build-env /go/src/welcome-app/welcome-app /app
COPY --from=build-env /go/src/welcome-app/templates /app/templates
COPY --from=build-env /go/src/welcome-app/static /app/static
#Here we copy the binary from the first image (build-env) to the new alpine container
EXPOSE 8080
ENTRYPOINT [ “./welcome-app” ]
#We then run it on entry! 

Résultat :

MBP-de-admin:welcome-app admin$ docker images
REPOSITORY                                    TAG                 IMAGE ID            CREATED             SIZE
welcome-app                                   latest              b6953870f9fa        41 hours ago        17.5MB
eu.gcr.io/gke-test-node-26/welcome-app        latest              b6953870f9fa        41 hours ago        17.5MB

La nouvelle image représente 3,5% de la taille de l'original, avec les mêmes fonctionnalités.

Partie 3 : Kubernetes

On installe la cli de Gcloud :

gcloud components install kubectl

Étape 1 - Transférer notre conteneur dans le registre de conteneurs Google

Pour que Kubernetes puisse utiliser notre conteneur dans un conteneur, nous devons le télécharger dans un registre qu’il peut extraire facilement. Notre meilleure solution est Google Container Registry (GCR). GCR est une plate-forme de stockage et de gestion de conteneurs hébergée sur Google. Où vous pouvez stocker vos conteneurs de la même manière que Docker hub, toutefois, par défaut, dans GCR, vos conteneurs sont privés et facilement accessibles par tout service Google Cloud auquel vous souhaitez intégrer.  GCR a une convention de dénomination d'image à laquelle nous devons adhérer.

gcr.io/<gcloud-project-id>/image-name:version

Nous devons donc changer le nom de notre image de bienvenue, welcome-app: 1.2, pour l'adapter à la convention.

//Changes the name of the image
docker tag welcome-app:1.2 gcr.io/<my-gcloud-project-id>/welcome-app:latest
//Pushes to GCR
gcloud docker -- push gcr.io/<my-gcloud-project-id>/welcome-app:latest

Ce qui donne me concernant :

MBP-de-admin:~ admin$ docker tag welcome-app eu.gcr.io/gke-test-node-26/welcome-app:latest
MBP-de-admin:~ admin$ gcloud docker -- push eu.gcr.io/gke-test-node-26/welcome-app:latest
WARNING: `gcloud docker` will not be supported for Docker client versions above 18.03.

As an alternative, use `gcloud auth configure-docker` to configure `docker` to
use `gcloud` as a credential helper, then use `docker` as you would for non-GCR
registries, e.g. `docker pull gcr.io/project-id/my-image`. Add
`--verbosity=error` to silence this warning: `gcloud docker
--verbosity=error -- pull gcr.io/project-id/my-image`.

See: https://cloud.google.com/container-registry/docs/support/deprecation-notices#gcloud-docker

The push refers to repository [eu.gcr.io/gke-test-node-26/welcome-app]
0215fd357537: Pushed 
56fa0f68ef2b: Pushed 
b3c1960265db: Pushed 
a3c8d57931a4: Pushed 
2625ed895759: Pushed 
df64d3292fd6: Layer already exists 
latest: digest: sha256:29b83d6f6c4f2e81aa467fa03dbced9644990a60c3c62e4326d1ceec90235f7d size: 1573

Nice ! Notre image a maintenant été téléchargée sur GCR dans le cadre de notre projet (le nom de votre projet peut différer du mien, mais ce n'est pas grave!)  

Étape 2 : Création d'un cluster Kubernetes sur GKE.

Une fois encore, GKE étant une solution gérée par Kubernetes, nous n’avons pas à nous soucier de la configuration, par exemple. réseau, etc., la création d’un cluster Kubernetes est donc très simple.

MBP-de-admin:~ admin$ gcloud container clusters create cloud-build-example \
>       --zone europe-west1-b \
>       --enable-autorepair \
>       --num-nodes 2 \
>       --enable-autoscaling \
>       --min-nodes 2 \
>       --max-nodes 4

Après quelque temps, nous pouvons vérifier si votre cluster est en cours d'exécution

gcloud container clusters list

Nous devons maintenant connecter notre machine locale à Kubernetes s'exécutant dans notre cluster. N'oubliez pas que tout ce que nous avons fait jusqu'à présent est simplement de créer un cluster exécutant Kubernetes. Nous n’avons actuellement pas accès à Kubernetes au sein du cluster.  

Pour ce faire :

gcloud container clusters get-credentials welcome-app-cluster

résultat en console :

MBP-de-admin:~ admin$ gcloud container clusters list
NAME                 LOCATION        MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
cloud-build-example  europe-west1-b  1.9.7-gke.11    35.187.15.228  n1-standard-1  1.9.7-gke.11  2          RUNNING
MBP-de-admin:~ admin$ gcloud container clusters get-credentials cloud-build-example
Fetching cluster endpoint and auth data.
kubeconfig entry generated for cloud-build-example.
MBP-de-admin:~ admin$ kubectl get nodes 
NAME                                                 STATUS    ROLES     AGE       VERSION
gke-cloud-build-example-default-pool-6afd3b13-c6vm   Ready     <none>    33m       v1.9.7-gke.11
gke-cloud-build-example-default-pool-6afd3b13-m5xh   Ready     <none>    33m       v1.9.7-gke.11

Cela prend notre cluster et relie notre installation locale de kubectl à celle qui s'exécute sur le cloud (elle pointe essentiellement notre installation Kubernetes locale vers le fichier kubeconfig qui s'exécute dans le cluster cloud.)

Ce fichier fournit à notre ordinateur local toutes les informations nécessaires sur la manière dont Kubernetes s'exécutant dans notre cluster cloud est configuré.  Pour confirmer, nous pouvons réellement exécuter la commande suivante sur notre machine locale (comme vu ci-dessus):

kubectl get nodes

Maintenant que nous avons accès à Kubernetes sur notre ordinateur local, exécutons notre application à l’aide de la commande suivante.

MBP-de-admin:~ admin$ kubectl run welcome-app --image=eu.gcr.io/gke-test-node-26/welcome-app:latest --port=8080
deployment.apps "welcome-app" created

Dans la plupart des cas, notre conteneur ne peut communiquer avec des conteneurs situés dans le même port que si nous l'exposons de manière externe vers un autre nœud, un autre réseau ou avec le reste du monde. Pour pouvoir accéder à nos conteneurs de manière globale, nous créons un service sous la forme d'un load balancer.

//Here we create a load balancer service that can be connected to through port 80, and targets our containers at port 8080. 
kubectl expose deployment welcome-app --type=LoadBalancer --target-port=8080 --port 80

Load Balancer rend notre conteneur disponible dans le monde entier. Si nous faisons un simple :

MBP-de-admin:~ admin$ kubectl get services
NAME          TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes    ClusterIP      10.11.240.1     <none>        443/TCP        35m
welcome-app   LoadBalancer   10.11.253.157   <pending>     80:31786/TCP   12s

Nous voyons l'équilibreur de charge avec une adresse IP externe (vous devrez peut-être attendre une minute pour que Google mette à disposition une adresse IP).  

MBP-de-admin:~ admin$ kubectl get services
NAME          TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
kubernetes    ClusterIP      10.11.240.1     <none>         443/TCP        36m
welcome-app   LoadBalancer   10.11.253.157   35.240.43.93   80:31786/TCP   1m

Si nous plaçons cette adresse IP dans notre navigateur, nous sommes dirigés vers notre application.

Étape 3: nettoyage.

Afin de ne pas engager plus de frais, nous devons supprimer notre instance sur Gcloud.

gcloud container clusters delete welcome-app — -zone=europe-west1-b

Avant de tout supprimer il peut être utile de poursuivre le travail et surtout de l'approfondir sur deux points :

  • Monitoring et supervision
  • Git --> repository pour mener une démarche de Ci/Cd ou Gitops.

"Gitops"

On va commencer par créer un repository Github de notre projet :

Puis dans notre terminal nous allons nous rendre dans le bon dossier de notre application.

git init
Dépôt Git vide initialisé dans /Users/admin/go/src/github.com/gabrielsagnard/welcome-app/.git/

Après cela, créons les conditions nécessaires à un joli commit :

MBP-de-admin:welcome-app admin$ echo "node_modules" > .gitignore
MBP-de-admin:welcome-app admin$ git add .

Puis on commit :

MBP-de-admin:welcome-app admin$ git commit -m "Initial commit"
[master (commit racine) 4ac8b0c] Initial commit
 9 files changed, 167 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 .gitignore
 create mode 100644 Dockerfile
 create mode 100644 app.yaml
 create mode 100644 main.go
 create mode 100644 static/stylesheets/background.jpeg
 create mode 100644 static/stylesheets/welcome-template.css
 create mode 100644 templates/welcome-template.html
 create mode 100644 templates/welcome-templates.html

Puis on pushe :

MBP-de-admin:welcome-app admin$ git remote add origin https://github.com/gabrielsagnard/welcome-app.git
MBP-de-admin:welcome-app admin$ git push -u origin master
Énumération des objets: 13, fait.
Décompte des objets: 100% (13/13), fait.
Compression par delta en utilisant jusqu'à 8 fils d'exécution
Compression des objets: 100% (11/11), fait.
Écriture des objets: 100% (13/13), 3.43 MiB | 96.00 KiB/s, fait.
Total 13 (delta 0), réutilisés 0 (delta 0)
remote: 
remote: Create a pull request for 'master' on GitHub by visiting:
remote:      https://github.com/gabrielsagnard/welcome-app/pull/new/master
remote: 
To https://github.com/gabrielsagnard/welcome-app.git
 * [new branch]      master -> master
La branche 'master' est paramétrée pour suivre la branche distante 'master' depuis 'origin'.

Il ne reste désormais plus qu'à effectuer des modifs sur votre repo et synchroniser tout cela avec votre terminal local puis votre container registry dans le cloud.

Monitorer

Il faut démarrer en installant Helm, petit rappel ici, mais il faut également avec un cluster Kubernetes fonctionnel évidemment.

L’opérateur Prometheus permet de surveiller facilement les services et les déploiements de k8, en plus de la gestion de la configuration de Prometheus, d’Alertmanager et de Grafana.

Lorsque vous déployez une nouvelle version de votre application, k8s crée un nouveau pod (conteneur) et, une fois prêt, les k8 détruisent l'ancien. Prometheus surveille en permanence l'api de k8s et lorsqu'il détecte un changement, il crée une nouvelle configuration Prometheus, basée sur les modifications apportées aux services (pods).

Schéma de principe du service de monitoring

Installation

$ helm repo add coreos https://s3-eu-west-1.amazonaws.com/coreos-charts/stable/
$ helm install coreos/prometheus-operator --name prometheus-operator --namespace monitoring
$ helm install coreos/kube-prometheus --name kube-prometheus --set global.rbacEnable=true --namespace monitoring

En supposant que tout va bien, vous pouvez exécuter la commande ci-dessous pour répertorier les applications que nous examinerons de plus près lors de la prochaine session

MBP-de-admin:welcome-app admin$ kubectl get pods  -n monitoring
NAME                                                   READY     STATUS    RESTARTS   AGE
alertmanager-kube-prometheus-0                         2/2       Running   0          6m
kube-prometheus-exporter-kube-state-56cc58897c-wbz27   2/2       Running   0          3m
kube-prometheus-exporter-node-9ljb6                    1/1       Running   0          3m
kube-prometheus-exporter-node-hk7vl                    1/1       Running   0          6m
kube-prometheus-exporter-node-nmljk                    1/1       Running   0          6m
kube-prometheus-grafana-7bcb88ff5f-89crh               2/2       Running   0          6m
prometheus-kube-prometheus-0                           3/3       Running   1          6m
prometheus-operator-7f58c745d6-zkxp5                   1/1       Running   0          8m

Prometheus

Transférez le serveur Prometheus sur votre ordinateur afin que vous puissiez mieux consulter le tableau de bord en ouvrant http://localhost:9090

MBP-de-admin:welcome-app admin$ kubectl port-forward -n monitoring prometheus-kube-prometheus-0 9090
Forwarding from 127.0.0.1:9090 -> 9090

Dans le tableau de bord Prometheus, vous pouvez:

interroger sur les métriques, voir toutes les alertes prédéfinies et les cibles Prometheus.

Grafana

Prometheus dispose d’un navigateur d’expression à des fins de débogage. Pour avoir un beau tableau de bord, utilisez Grafana, il dispose d’une data source prête à interroger Prometheus.

MBP-de-admin:welcome-app admin$ kubectl port-forward $(kubectl get  pods --selector=app=kube-prometheus-grafana -n  monitoring --output=jsonpath="{.items..metadata.name}") -n monitoring  3000
Forwarding from 127.0.0.1:3000 -> 3000

Attendez quelques secondes jusqu'à ce que Grafana charge les tableaux de bord, ouvrez votre navigateur à l'adresse http://localhost:3000 pour consulter votre tout nouveau tableau de bord.

Des dashboards tout prêts, tout beaux.

Alert Manager

Alert manager gère les alertes envoyées par les applications clientes telles que le serveur Prometheus. Il prend en charge la déduplication, le regroupement et le routage vers la bonne intégration du destinataire, telle que la messagerie, PagerDuty ou OpsGenie. Il prend également en charge le silence et l'inhibition des alertes.

Nous avons déjà installé Alert manager, à présent saisissez la commande ci-dessous, pour transférer le port sur votre ordinateur et ouvrir l’url http://localhost:9093 dans votre navigateur  

$ kubectl port-forward -n surveillance alertmanager-kube-prometheus-0 9093

Conclusion

Dans ce didacticiel, nous avons exécuté quelques commandes gcloud et kubectl afin de télécharger notre image de conteneur vers Google Container Registry (GCR). Nous avons démarré notre cluster GKE, extrait notre image de GCR et déployé celle-ci sur un module de travail. Nous avons utilisé un équilibreur de charge pour exposer notre pod au monde entier, nous permettant ainsi d'accéder à notre application de bienvenue Go à distance.

Kubernetes est en train de devenir un moyen extrêmement populaire pour le développement d'applications Web. Ce tutoriel a à peine effleuré la surface de ce qui est capable. Les prochains articles porteront sur les composants internes de Kubernetes et GKE.  Merci encore une fois d’avoir lu cette série de tutoriels et espérons que cela vous aura aidé à apprendre à créer une application Go et à la déployer sur l’infrastructure de Google Cloud.

Bibliographie :