Prometheus : Monitor docker services with grafana

Here is a little tutorial to setup Prometheus monitoring for a local docker daemon and host metrics with docker-compose and :

  • prometheus node exporter for system metrics
  • cadvisor for docker metrics

First create a prometheus.yml config file like this :

global:
alerting:
  alertmanagers:
    - static_configs:
      - targets:
#       - alertmanager:9093
rule_files:
 # - "first_rules.yml"
 # - "second_rules.yml"
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
    file_sd_configs:
      - files:
        - '/etc/prometheus/file_sd_configs.yml'

And a file service discovery config file_sd_configs.yml:

- targets:
  - grafana:3000
  - prom-node-exporter:9100
  - cadvisor:8080

Now it’s time to start all services with a docker-compose file.

I’m still using the great traefik for reverse proxy and ssl let’s encrypt certificate generation.

So here is my docker-compose :

version: '2'
services:
   traefik:
    image: traefik
    hostname: traefik
    container_name: traefik
    command: -c /etc/traefik/traefik.toml
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "/data/traefik/traefik.toml:/etc/traefik/traefik.toml"
      - "/data/traefik/acme.json:/etc/traefik/acme.json"
      - "/data/traefik/ssl:/etc/traefik/ssl"
      - "/var/run/docker.sock:/var/run/docker.sock"

  prometheus:
    image: prom/prometheus
    hostname: prometheus
    container_name: prometheus
    volumes:
      - "/data/docker/volumes/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml"
       - "/data/docker/volumes/prometheus/file_sd_configs.yml:/etc/prometheus/file_sd_configs.yml"
     labels:
      - "traefik.frontend.rule=Host:prometheus.aperogeek.fr"
 
  prom_node_exporter:
    image: prom/node-exporter
    hostname: prom-node-exporter
    container_name: prom-node-exporter
    labels:
      - "traefik.enable=false"
 
  cadvisor:
    image: google/cadvisor:latest
    hostname: cadvisor
    container_name: cadvisor
    volumes:
      - "/:/rootfs:ro"
      - "/var/run:/var/run:rw"
      - "/sys:/sys:ro"
      - "/var/lib/docker/:/var/lib/docker:ro"
    labels:
      - "traefik.enable=false"
 
  grafana:
    hostname: grafana
    container_name: grafana
    image: grafana/grafana
    environment:
      - GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-piechart-panel
    volumes:
      - /data/grafana:/var/lib/grafana
    labels:
      - "traefik.frontend.rule=Host:grafana.aperogeek.fr"

Then I needed to create a prometheus datasource in grafana

And finally I’ve just imported some public grafana dashboards. 

And voila 🙂

Wetty : un terminal dans ton navigateur

J’avais déjà fait un article sur GateOne, il y a un moment déjà. Mais celui-ci était plutôt lourd et difficile à installer.

wetty

Et la dernièrement je suis tombé sur Wetty, une web app codée en NodeJS permettant d’avoir un terminal dans le navigateur !

Idéal pour pouvoir accéder à son serveur depuis le boulot quand tous les ports sont bloqués 😉

Du coup, j’ai créé une petite image Docker dont voici le dockerfile :

FROM alpine:edge

RUN apk --update add git nodejs python build-base openssh-client

WORKDIR /usr/share/webapps

RUN git clone https://github.com/krishnasrinivas/wetty && \
    cd wetty && \
    npm install

RUN apk del build-base

WORKDIR /usr/share/webapps/wetty

RUN addgroup seuf
RUN adduser -G seuf -h /home/seuf -s /bin/ash -D seuf

RUN echo "seuf:PassWordSecretAChanger" | chpasswd

RUN chown -R seuf:seuf /home/seuf/.ssh

CMD node app.js -p 3000

Ensuite je rajoute une petite section wetty dans mon docker compose :

  wetty:
    image: seuf/wetty
    hostname: wetty
    container_name: ssh
    expose:
      - "3000"
    restart: always

Et hop, grâce à Traefik j’ai un client web ssh dans mon terminal en https !

Je n’ai plus qu’à me connecter dessus pour atterrir dans un conteneur Alpine Linux. Je peux ensuite rebondir en ssh sur n’importe quel autre serveur ssh.

Traefik : HTTP reverse proxy / Load balancer pour Docker

traefik.logo

Lors de ma formation Docker par @emilevauge, il nous avait rapidement montré son outil de reverse proxy et load balancer écrit en Go pour Docker : Træfɪk

La conf est super simple, il suffit de lui donner accès a l’API Docker (socket / port) ou n’importe quel autre Backend (Kubernetes, Etcd, consul, etc..) et traefik se débrouille tout seul pour automatiquement créer les routes vers les conteneurs !

Du coup, je l’ai utilisé pour mes propres besoin. L’avantage c’est qu’il gère aussi le https et même la génération des certificats avec Let’s Encrypt !

Comme j’utilise principalement docker-compose pour gérer les services, j’ai juste ajouté une entrée dans mon docker-compose.yml :

version: '2'

services:
  traefik:
    image: traefik
    hostname: traefik
    container_name: traefik
    command: --web --docker --docker.domain=aperogeek.fr  --logLevel=DEBUG --acme --acme.email=xxx@domain.com --acme.storagefile=/etc/traefik/acme.json --acme.entrypoint=https --acme.caserver='https://acme-staging.api.letsencrypt.org/directory' --acme.ondemand=true --entryPoints='Name:https Address::443 TLS:/etc/traefik/ssl/aperogeek.fr.pem,/etc/traefik/ssl/aperogeek.fr.key' --entryPoints='Name:http Address::80 Redirect.EntryPoint:https' --defaultentrypoints=http,https
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - "./ssl:/etc/traefik/ssl"
      - "/var/run/docker.sock:/var/run/docker.sock"
      - "/dev/null:/traefik.toml"
      - "/data/traefik/acme.json:/etc/traefik/acme.json"

Et voila !

Un coup de docker-compose up -d et traefik va détecter mes différents conteneurs et créer les routes qui vont bien 🙂

Ensuite, je n’avais plus qu’a créer des alias DNS pour pointer vers les bons sous domaines (foo.aperogeek.fr, etc..)

 

Alpine Linux : A Tiny Tiny Docker Image

Do you know Alpine Linux ? It’s a Tiny Linux distribution based on busybox.

Every one working with docker now that it takes a lot of disk space. That’s why here at ERDF Lyon we are using Docker-Alpine to build our own services..

It is very cool to have a very small containers, for example the base image is only 5 Mb, comparatively to a debian base docker or a centos it’s amazing !!

Here is a list of some images builds by our team :

[root@XXXXX ~]# docker images

REPOSITORY                                               TAG                 IMAGE ID            CREATED             VIRTUAL SIZE

library/alpine-java                  latest              b1ac8a415cc2        8 minutes ago       167 MB

library/alpine-nginx-php             latest              04dd1dd5f3a8        36 minutes ago      73.07 MB

library/alpine-adaje-nginx           latest              babdce2f7acb        2 hours ago         22.34 MB

library/alpine-influxdb              latest              8c1c8602ab3d        5 hours ago         43.71 MB

library/alpine-grafana               latest              87e008359f09        7 hours ago         105 MB

alpine-libc                          latest              768e1a26255d        8 hours ago         14.01 MB

alpine                               latest              809d1eb48c44        9 weeks ago         5.244 MB

library/centos6                      latest              5af3557457ba        5 months ago        396.1 MB

 

as you can see the base alpine is only 5.2MB, an Alpine image with nginx is only 43 MB and even an image with the full java runtime pre-installed is 167MB.

Against a centos6 base (with nothing on it) that takes nearly 400MB : y’a pas photo !!

 

We already have our own docker registry so we just have to build and push a lot of new images base on this tiny Docker image..

Here what’s in the pipeline :

  • alpine-mysql
  • alpine-postgresql
  • alpine-apache (already build from a centos)
  • alpine-zabbix-server
  • alpine-zabbix-frontend
  • alpine-jenkins (already build from a centos)
  • alpine-python (already build from a centos)
  • alpine-ansible (already build from a centos)