Dockeriser un serveur physique Linux entier

Docker est habituellement utilisé dans le cadre d’architectures orientées micro-services car les conteneurs sont légers (comparés aux VMs tout du moins), faciles à configurer, faciles à faire communiquer, et peuvent être déployés très rapidement. Cependant Docker peut parfaitement être utilisé si vous cherchez à Dockeriser un serveur physique ou un VPS entier au sein d’un seul et unique conteneur. Je vais tenter de vous montrer comment et dans quel but.

Contexte

J’ai récemment eu à travailler sur un projet développé par plusieurs des personnes ayant quitté l’entreprise avant mon arrivée. Je n’ai jamais eu l’opportunité de les rencontrer et les contacter était difficile. Malheureusement une grande partie du projet n’était pas documentée. Et en plus de tout cela, seulement certaines briques du projet étaient gérées via un outil de contrôle de version (Git ici). Bien entendu il n’existait aucun serveur de dev ou de staging : tout était directement déployé sur le serveur de production… Est-ce que vous commencez à sentir les soucis arriver ?

Il s’agissait d’un projet de web scraping accomplissant pas mal de tâches complexes. La stack technique du serveur de prod était en gros la suivante :

  • Ubuntu 16.04
  • Nginx
  • Postgresql 9.3
  • Python/Django
  • Python virtualenvs
  • Gunicorn
  • Celery
  • RabbitMQ
  • Scrapy/Scrapyd

Première tentative : échec

Je me suis arraché les cheveux à essayer de faire la rétro-ingénierie de ce serveur de production. Mon but ultime était d’isoler chaque application, la Dockeriser, et faire communiquer entre eux les différents conteneurs.

Mais ça a été un échec !

J’ai réussi à Dockeriser Nginx, l’application Django, et le système de gestion des tâches asynchrones (Celery), mais impossible de faire fonctionner Scrapy et Scrapyd correctement. Je pense que cela venait principalement du fait que des développements spécifiques avaient été apportés directement aux fichiers sources des bibliothèques Scrapy et Scrapyd par les précédents développeurs (c’est à dire au sein du répertoire python/site-package lui-même !) et le tout bien entendu sans aucune doc. Par ailleurs certaines bibliothèques Python utilisées à l’époque ne sont plus disponibles aujourd’hui, ou bien sont disponibles mais plus dans la bonne version (vous pouvez oublier pip freeze et pip install -r requirements.txt ici).

Deuxième tentative : échec

J’ai en fin de compte abandonné l’idée d’une architecture de type micro-service trop compliquée à monter ici. Mais il n’empêche que j’avais un besoin urgent de sécuriser le serveur de production avant qu’il ne rencontre des problèmes. La base de donnée était sauvegardée à intervalles réguliers mais rien d’autre sur le serveur n’était sauvegardé.

J’ai pensé à créer une image système de tout le serveur en utilisant un outil comme CloneZilla ou une simple commande rsync comme celle-là. Mais un tel backup ne m’aurait pas permis de continuer à faire évoluer facilement le projet en y intégrant de nouvelles fonctionnalités.

C’est pourquoi j’ai aussi étudié la possibilité de convertir le serveur physique en machine virtuelle VMWare en utilisant leur outil VMware vCenter Converter mais le lien de téléchargement était cassé et si peu de personnes mentionnaient cet outil que j’ai pris peur et abandonné.

Enfin, j’ai essayé cette solution de Dockerisation basée sur Blueprint mais sans réussir à vraiment la faire complètement fonctionner, et Blueprint semblait par ailleurs un projet à l’arrêt.

Troisième tentative : réussie

En réalité la solution était relativement simple : j’ai décidé de Dockeriser l’intégralité du serveur de prod par moi-même - à l’exception des données Postgresql - de façon à avoir une sauvegarde du serveur sous forme d’image Docker et à pouvoir ajouter de nouvelles fonctionnalités à mon conteneur sous forme de commits successifs vers de nouvelles images. Le tout sans avoir peur de casser le serveur pour toujours. Voici comment je m’y suis pris :

1. Installez et paramétrez Docker sur le serveur

  1. Installez Docker en suivant ce guide.
  2. Loguez-vous à votre compte Docker Hub: docker login
  3. Créez un réseau Docker (si besoin): docker network create --subnet=172.20.0.0/16 my_network

2. Créez une image Docker de votre serveur

Rendez-vous à la racine de votre serveur :

cd /

Créez le fichier Dockerfile suivant basé sur Ubuntu 16.04 LTS (sans la partie dédiée à Nginx et Rabbitmq bien sûr) :

FROM ubuntu:xenial

# Copy the whole system except what is specified in .dockerignore
COPY / /

# Reinstall nginx and rabbitmq because of permissions issues in Docker
RUN apt remove -y nginx
RUN apt install -y nginx
RUN apt remove -y rabbitmq-server
RUN apt install -y rabbitmq-server

# Launch all services
COPY startup.sh /
RUN chmod 777 /startup.sh
CMD ["bash","/startup.sh"]

Créez le fichier .dockerignore qui mentionnera tous les fichiers ou répertoires que vous souhaitez exclure de la commande COPY ci-dessus. C’est là qu’il vous faut utiliser votre intuition. Excluez autant de fichiers que possible de façon à ce que l’image Docker ne soit pas trop volumineuse, mais n’excluez pas les fichiers vitaux pour votre application. Voici mon fichier mais bien entendu à vous de l’adapter à votre propre serveur :

# Remove folders mentioned here:
# https://wiki.archlinux.org/index.php/Rsync#As_a_backup_utility
/dev 
/proc
/sys
/tmp
/run
/mnt
/media
/lost+found

# Remove database's data
/var/lib/postgresql

# Remove useless heavy files like /var/lib/scrapyd/reports.old
**/*.old
**/*.log
**/*.bak

# Remove docker
/var/lib/lxcfs
/var/lib/docker
/etc/docker
/root/.docker
/etc/init/docker.conf

# Remove the current program
/.dockerignore
/Dockerfile

Créez un script startup.sh afin de lancer tous les services au démarrage du conteneur et de mettre en place les redirections vers la base de donnée. Ici mon script va être radicalement différent du vôtre bien entendu :

# Redirect all traffic from 127.0.0.1:5432 to 172.20.0.1:5432
# so any connection to Postgresql keeps working without any other modification.
# Requires the --privileged flag when creating container:
sysctl -w net.ipv4.conf.all.route_localnet=1
iptables -t nat -A OUTPUT -p tcp -s 127.0.0.1 --dport 5432 -j DNAT --to-destination 172.20.0.1:5432
iptables -t nat -A POSTROUTING -j MASQUERADE

# Start RabbitMQ.
rabbitmq-server -detached

# Start Nginx.
service nginx start

# Start Scrapyd
/root/.virtualenvs/my_project_2/bin/python /root/.virtualenvs/my_project_2/bin/scrapyd >> /var/log/scrapyd/scrapyd.log 2>&1 &

# Use Python virtualenvwrapper
source /root/.profile

# Start virtualenv and start Django/Gunicorn
workon my_project_1
cd /home/my_project_1
export DJANGO_SETTINGS_MODULE='my_project_1.settings.prod'
gunicorn -c my_project_1/gunicorn.py -p /tmp/gunicorn.pid my_project_1.wsgi &

# Start Celery
export C_FORCE_ROOT=True
celery -A my_project_1 beat &
celery -A my_project_1 worker -l info -Q queue1,queue2 -P gevent -c 1000 &

# Little hack to keep the container running in foreground
tail -f /dev/null

Comme vous pouvez le voir, j’utilise des redirections iptables de façon à ce que toutes les connections vers la base de données Postgresql (port 5432) continuent de fonctionner sans modification supplémentaire des fichiers de configuration. En effet ma base de données était initialement située sur le localhost, mais elle est désormais située sur l’hôte Docker dont l’ip est 172.20.0.1 (j’ai tout copié vers le conteneur Docker à l’exception de la base de données). Les redirections au niveau du kernel sont assez pratiques lorsque vous ne savez pas où sont situés tous vos fichiers de configuration, et elles sont indispensables si vous n’êtes pas du tout en mesure de modifier ces fichiers de config (comme dans le cas d’une application compilée dont vous n’avez pas le code source).

Maintenant lancez la création de l’image et patientez… Dans mon cas, l’image pesait environ 3Go et a été créée en 5 minutes. Assurez-vous d’avoir suffisamment d’espace disque à disposition sur votre serveur avant de lancer la commande.

docker build -t your_repo/your_project:your_tag .

Si vous n’avez obtenu aucune erreur ici, alors bravo vous avez fait le plus dur ! A présent testez votre image et voyez si tout fonctionne normalement. Si ce n’est pas le cas il vous faut certainement adapter un des 3 fichiers ci-dessus.

3. Sauvegardez votre nouvelle image Docker

Uploadez simplement votre image sur le Hub Docker :

docker build -t your_repo/your_project:your_tag .

4. Intégrez de nouvelles fonctionnalités à votre image serveur

Désormais, si vous avez besoin de travailler sur cette image serveur, vous pouvez procéder comme suit :

  1. créez un conteneur basé sur cette image avec docker run (n’oubliez pas de spécifier le nom du réseau, l’adresse ip, le forwarding de ports, et d’ajouter l’option --privileged afin que la commande sysctl présente dans startup.sh fonctionne)
  2. travaillez dans votre conteneur
  3. faites un commit des changements effectués vers une nouvelle image Docker avec docker commit
  4. uploadez votre nouvelle image sur le Docker Hub avec docker push et déployez-la en staging ou en production

Conclusion

Cette solution m’a vraiment sauvé la mise et il me semble qu’elle prouve bien que Docker est un excellent outil, pas uniquement pour les architectures micro-service mais aussi dans le cadre d’une conteneurisation d’un serveur entier. Dockeriser un serveur entier peut être une excellente solution si vous avez besoin de sécuriser un serveur de prod existant tel que le mien ici sans documentation, sans dépôt GitHub, et sans les développeurs historiques.

La première image à créer peut être assez lourde, mais par la suite chaque commit n’est pas si gros grâce à l’architecture en couches de Docker.

S’agit-il d’un hack ? Peut-être bien mais qui fonctionne à la perfection alors !

J’aimerais beaucoup entendre l’avis d’autre devs là-dessus.

Also available in English
CTOs, développeurs : comment choisir une bonne API externe ?

De nos jours trouver une API externe permettant d’améliorer la qualité de son service est devenu très facile. De plus en plus d’entreprises mettent à disposition des APIs. Problème : de nombreux développeurs/CTOs se lancent dans l’intégration alors que cette dernière ne devrait être en fait que l’ultime étape ! Avant cela il vous faut déterminer si la qualité de l’API répond à un minimum d’exigences. Voici comment je m’y prends personnellement. J’espère que cela aidera d’autres CTOs et développeurs.

Qualité des données

De nombreuses APIs exposent des données vous permettant d’enrichir votre propre système (ce n’est pas le cas de toutes les APIs bien entendu, Stripe n’est pas une API d’enrichissement par exemple). Il est essentiel que vous vous assuriez de la qualité de ces données. Cela va vous prendre pas mal de temps et je sais déjà que vous n’aimez pas les tests ! Moi non plus, mais néanmoins vous ne pouvez pas vous soustraire à la création d’un scénario de test rigoureux ici. Si vous réalisez que la qualité des données fournies n’était pas suffisamment bonne seulement deux semaines après avoir fini votre intégration, croyez-moi vous le regretterez…

Documentation

Je suis récemment tombé sur une API qui exposait des données de grande qualité (bien meilleure que ce proposait la concurrence selon moi), mais sa documentation était… un cauchemar ! En réalité il n’y avait pour ainsi dire pas de documentation. Par ailleurs l’API ne respectait pas toutes les conventions REST. Comment pouvez-vous réussir à intégrer une API externe si les codes erreurs ne sont pas proprement documentés ? Hé bien l’unique solution qu’il vous reste dans ce cas est de tester encore et encore l’API afin de comprendre son fonctionnement. Le rétro-engineering peut être amusant mais demande aussi beaucoup de temps. Rappelez-vous que dans le cas d’une API vous n’avez pas de dépôt GitHub à explorer puisque le code source n’est pas disponible… Une mauvaise doc est systématiquement synonyme de perte de temps pour les devs, et sûrement de mauvaises surprises à moyen terme.

Bibliothèques

Est-il possible d’intégrer l’API via une bibliothèque disponible dans votre langage favori ? En tant que développeur Python et Go je suis toujours enchanté lorsque je tombe sur une API qui offre une lib Python (je sais qu’en ce qui concerne Go je peux oublier pour l’instant). Cela peut vous faire gagner pas mal de temps, mais avant tout assurez-vous que la bibliothèque est mûre et couvre toutes les fonctionnalités de l’API (pas toujours le cas).

Notoriété de l’éditeur

La notoriété peut vous aider à éclairer votre choix et éviter les mauvaises surprises avec votre API à l’avenir. Par mauvaises surprises j’entends interruption de service, régression de certaines fonctionnalités, ou même arrêt définitif du service… Vous pouvez en partie éviter ces écueils en vous posant les questions suivantes :

  • est-ce que cette API est connue sur le net (en général si vous trouvez peu d’information, fuyez) ? Trouvez-vous de nombreux articles/tutoriels parlant de l’API ? Ces articles sont-ils élogieux ?
  • des entreprises réputées l’utilisent-elles ?
  • si l’entreprise a développé des bibliothèques dédiées, sont-elles bien notées sur GitHub ? Les problèmes remontés sur GitHub sont-ils traités régulièrement ?
  • y a-t-il eu des mises à jour récentes de l’API ou la dernière mis à jour a-t-elle eu lieu il y a longtemps ?

Support technique

Assurez-vous que quelqu’un réponde à vos questions rapidement par email lorsque vous rencontrez un problème et que la réponse est pertinente. Si vous êtes basé en Europe et que l’API est éditée par une entreprise américaine, assurez-vous que le décalage horaire ne pose pas de problème.

Respect des conventions

A mon humble avis, toute API sérieuse aujourd’hui se doit d’être une API RESTful. Si l’API que vous affectionnez ne respecte pas les conventions REST, alors soyez méfiant. Toutefois gardez à l’esprit quel le standard REST n’est pas clair sur tous les sujets et que chaque API peut avoir sa propre déclinaison (codes HTTP, encodage des requêtes POST, …). Il n’empêche que vous devez lire la documentation attentivement et vous assurer que vous ne constatez pas de pratique trop originale. L’originalité vous ralentira…

Prix

Bien entendu le prix est de première importance. Mais attention la tarification d’une API n’est pas toujours facile à comprendre. Allez-vous être facturé au mois pour un nombre illimité de requêtes ? Facturé à la requête ? Dans ce second cas allez-vous être facturé deux fois pour 2 requêtes identiques (dans le cas d’une API d’enrichissement) ou la seconde requête sera-t-elle gratuite ? Serez-vous facturé pour une requête ne retournant aucun résultat (HTTP 404) ? Assurez-vous de bien comprendre toutes ces implications.

Qualité de service (QoS)

La qualité de service est très importante. Votre but est de travailler avec une API aussi rapide que possible et avec le moins d’interruptions de service possible. Malheureusement il ne s’agit pas de performances faciles à tester. En effet la qualité de service varie avec le temps, et de nombreuses APIs offrent deux niveaux de QoS différents selon que vous utilisez la version gratuite ou payante… Parfois vous pouvez même choisir entre différents abonnements avec différents temps de réponse.

Support des requêtes parallèles

Selon la façon dont vous prévoyez d’intégrer l’API, vous pouvez avoir envie d’accélérer les choses en consultant l’API via plusieurs requêtes simultanées au lieu du comportement séquentiel classique. Personnellement j’utilise Golang pour cela. Si c’est le cas soyez vigilant : de nombreuses API ne supportent pas les requêtes parallèles et lorsque c’est le cas elles imposent nécessairement une limite. Dans ce cas assurez-vous d’avoir demandé à l’éditeur quelle était cette limite (pas toujours mentionné dans la doc) et adaptez votre script en fonction.

Cet article sera un bon mémo pour moi, j’espère que pour vous aussi !

Also available in English | También existe en Español
Utilisatation d'une API REST : Go vs Python

Les API sont partout de nos jours. Imaginez : vous souhaitez recueillir des informations sur vos prospects à partir de leurs emails. Hé bien il y a une API pour ceci. Vous avez besoin de géocoder une adresse postale mal formatée ? Il existe aussi une API pour cela. Enfin, vous cherchez à effectuer un paiement de façon automatisée ? De nombreuses API font le job bien entendu. En tant que développeur, je suis régulièrement amené à intégrer des API externes à mon système, en Python ou en Go. Les deux méthodes sont assez différentes. Comparons-les sur un cas un peu “borderline” : l’envoi de données JSON encodées dans le body d’une requête POST.

Un exemple de la vie réelle

Récemment, j’ai utilisé l’API NameAPI.org dans le but de découper un nom entier en prénom et nom de famille, et déterminer le genre de la personne.

Leur API attend que vous lui envoyiez les données en JSON encodées dans le body d’une requête POST. De plus, le Content-Type de la requête doit être application/json et non pas multipart/form-data. Il s’agit d’un cas un peu piégeux puisqu’en général les données POST sont envoyées à travers le header de la requête, et si l’on décide de les envoyer dans le body de la requête (dans le cas de données JSON complexes par exemple) le Content-Type standard est multipart/form-data.

Voici le JSON que l’on veut envoyer :

{
  "inputPerson" : {
    "type" : "NaturalInputPerson",
    "personName" : {
      "nameFields" : [ {
        "string" : "Petra",
        "fieldType" : "GIVENNAME"
      }, {
        "string" : "Meyer",
        "fieldType" : "SURNAME"
      } ]
    },
    "gender" : "UNKNOWN"
  }
}

On peut le faire facilement via cURL :

curl -H "Content-Type: application/json" \
-X POST \
-d '{"inputPerson":{"type":"NaturalInputPerson","personName":{"nameFields":[{"string":"Petra Meyer","fieldType":"FULLNAME"}]}}}' \
http://rc50-api.nameapi.org/rest/v5.0/parser/personnameparser?apiKey=<API-KEY>

Et voici la réponse JSON de NameAPI.org :

{
"matches" : [ {
  "parsedPerson" : {
    "personType" : "NATURAL",
    "personRole" : "PRIMARY",
    "mailingPersonRoles" : [ "ADDRESSEE" ],
    "gender" : {
      "gender" : "MALE",
      "confidence" : 0.9111111111111111
    },
    "addressingGivenName" : "Petra",
    "addressingSurname" : "Meyer",
    "outputPersonName" : {
      "terms" : [ {
        "string" : "Petra",
        "termType" : "GIVENNAME"
      },{
        "string" : "Meyer",
        "termType" : "SURNAME"
      } ]
    }
  },
  "parserDisputes" : [ ],
  "likeliness" : 0.926699401733102,
  "confidence" : 0.7536487758945387
}

Maintenant voyons comment faire cela en Go et en Python !

Réalisation en Go

Code

/*
Fetch the NameAPI.org REST API and turn JSON response into a Go struct.

Sent data have to be JSON data encoded into request body.
Send request headers must be set to 'application/json'.
*/

package main

import (
    "encoding/json"
    "io/ioutil"
    "log"
    "net/http"
    "strings"
)

// url of the NameAPI.org endpoint:
const (
    url = "http://rc50-api.nameapi.org/rest/v5.0/parser/personnameparser?" +
        "apiKey=<API-KEY>"
)

func main() {

    // JSON string to be sent to NameAPI.org:
    jsonString := `{
        "inputPerson": {
            "type": "NaturalInputPerson",
            "personName": {
                "nameFields": [
                    {
                        "string": "Petra",
                        "fieldType": "GIVENNAME"
                    }, {
                        "string": "Meyer",
                        "fieldType": "SURNAME"
                    }
                ]
            },
            "gender": "UNKNOWN"
        }
    }`
    // Convert JSON string to NewReader (expected by NewRequest)
    jsonBody := strings.NewReader(jsonString)

    // Need to create a client in order to modify headers
    // and set content-type to 'application/json':
    client := &http.Client{}
    req, err := http.NewRequest("POST", url, jsonBody)
    if err != nil {
        log.Println(err)
    }
    req.Header.Add("Content-Type", "application/json")
    resp, err := client.Do(req)

    // Proceed only if no error:
    switch {
    default:
        // Create a struct dedicated to receiving the fetched
        // JSON content:
        type Level5 struct {
            String   string `json:"string"`
            TermType string `json:"termType"`
        }
        type Level41 struct {
            Gender     string  `json:"gender"`
            Confidence float64 `json:"confidence"`
        }
        type Level42 struct {
            Terms []Level5 `json:"terms"`
        }
        type Level3 struct {
            Gender           Level41 `json:"gender"`
            OutputPersonName Level42 `json:"outputPersonName"`
        }
        type Level2 struct {
            ParsedPerson Level3 `json:"parsedPerson"`
        }
        type RespContent struct {
            Matches []Level2 `json:"matches"`
        }

        // Decode fetched JSON and put it into respContent:
        respContentBytes, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            log.Println(err)
        }
        var respContent RespContent
        err = json.Unmarshal(respContentBytes, &respContent)
        if err != nil {
            log.Println(err)
        }
        log.Println(respContent)
    case err != nil:
        log.Println("Network error:", err)
    case resp.StatusCode != 200:
        log.Println("Bad HTTP status code:", err)
    }

}

Explications

Comme vous pouvez le voir, nous faisons face à 2 problèmes désagréables :

  • la bibliothèque http n’est pas si simple d’utilisation lorsqu’il s’agit d’encoder des données JSON au sein du body et de changer le header Content-Type. La doc de Go n’est pas très claire à ce sujet. Ainsi nous ne pouvons pas invoquer http.Post qui est plus simple d’utilisation et nous sommes contraints de créer un http.Client puis par la suite d’utiliser la fonction NewRequest() que l’on déclenche avec client.Do(req). C’est l’unique façon de créer un Content-Type personnalisé dans notre cas : req.Header.Add("Content-Type", "application/json")
  • décoder le JSON reçu de NameAPI en Go est assez long et fastidieux (procédé appelé Unmarshalling en Go). Cela vient du fait que, Go étant un langage statique, nous avons besoin de savoir à l’avance à quoi ressemblera le JSON final. Par conséquent nous avons besoin de créer une struct dédiée dont la structure sera la même que celle du JSON et qui recevra les données. En cas de JSON imbriqué tel que celui retourné par NameAPI.org, qui mélange des array et des maps, cela devient très délicat. Heureusement, notre struct n’a pas besoin de mapper tout le JSON mais seulement les champs qui nous intéressent. Une autre approche, si nous n’avons aucune idée de la structure de notre JSON, serait de deviner les types de données. Voici un bon article sur le sujet.

L’input jsonString est déjà une string ici. Mais pour une comparaison encore plus rigoureuse avec Python, cela aurait dû être une struct que l’on aurait par la suite convertie en string. Toutefois cela aurait rallongé l’article inutilement.

Réalisation en Python

Code

"""
Fetch the NameAPI.org REST API and turn JSON response into Python dict.

Sent data have to be JSON data encoded into request body.
Send request headers must be set to 'application/json'.
"""

import requests

# url of the NameAPI.org endpoint:
url = (
    "http://rc50-api.nameapi.org/rest/v5.0/parser/personnameparser?"
    "apiKey=<API-KEY>"
)

# Dict of data to be sent to NameAPI.org:
payload = {
    "inputPerson": {
        "type": "NaturalInputPerson",
        "personName": {
            "nameFields": [
                {
                    "string": "Petra",
                    "fieldType": "GIVENNAME"
                }, {
                    "string": "Meyer",
                    "fieldType": "SURNAME"
                }
            ]
        },
        "gender": "UNKNOWN"
    }
}

# Proceed, only if no error:
try:
    # Send request to NameAPI.org by doing the following:
    # - make a POST HTTP request
    # - encode the Python payload dict to JSON
    # - pass the JSON to request body
    # - set header's 'Content-Type' to 'application/json' instead of
    #   default 'multipart/form-data'
    resp = requests.post(url, json=payload)
    resp.raise_for_status()
    # Decode JSON response into a Python dict:
    resp_dict = resp.json()
    print(resp_dict)
except requests.exceptions.HTTPError as e:
    print("Bad HTTP status code:", e)
except requests.exceptions.RequestException as e:
    print("Network error:", e)

Explications

La bibliothèque Request est une bibliothèque incroyablement pratique qui nous épargne beaucoup d’efforts comparé à Go ! En une ligne, resp = requests.post(url, json=payload), presque tout est fait :

  • construire une requête POST HTTP
  • convertir le dictionnaire Python en JSON
  • passer le JSON au body de la requête
  • passer le 'Content-Type' du header de 'multipart/form-data' à 'application/json' grâce au kwarg json
  • envoyer la requête

Décoder le JSON retourné par NameAPI se fait aussi en une ligne : resp_dict = resp.json(). Nul besoin de créer une structure de données compliquée à l’avance ici !

Conclusion

Python est clairement le gagnant. La simplicité de Python combinée à sa quantité de bibliothèques disponibles nous épargne pas mal de temps de développement !

Nous n’abordons pas la question de la performance ici. Si vous recherchez une intégration d’API hautement performante utilisant la concurrence, Go pourrait être un excellent choix. Mais simplicité et performance vont rarement de paire…

N’hésitez pas à commenter, je serais heureux d’avoir votre avis sur ce comparatif.

Also available in English | También existe en Español
Comment accélérer le web scraping avec Go (Golang) et la concurrence ?

Je développe des web scrapers en Python depuis plusieurs années. La simplicité de Python permet de réaliser des prototypes rapides et ses nombreuses bibliothèques sont très utiles au scraping et au parsing des résultats (Requests, Beautiful Soup, Scrapy, …). Toutefois lorsque l’on commence à s’intéresser à la performance de notre scraper, Python montre certaines limites et Go entre dans la partie !

Pourquoi Go ?

Lorsque l’on essaie d’accélérer la récupération d’informations depuis le web (pour du scraping HTML comme pour du fetching d’API), deux pistes d’optimisation principales s’offrent à nous :

  • accélérer la récupération de la ressource web (ex : télécharger la page http://example.com/hello.html)
  • accélérer le parsing des informations récupérées (ex : récupérer toutes les url présentes sur hello.html)

On peut améliorer la performance du parsing en retravaillant son code, en utilisant un parser plus performant comme lxml, ou en allouant plus de ressources machine à notre scraper. Mais malgré tout cela, on se rend compte que l’optimisation du parsing est souvent négligeable et que le goulot d’étranglement, comme souvent, reste l’accès réseau (c’est à dire le téléchargement de la page web).

La solution est donc de paralléliser le téléchargement des différentes pages web. Et pour cela Go est tout indiqué !

La programmation concurrente est un domaine rapidement compliqué et Go a la capacité de rendre cela plutôt facile. Go est un langage moderne qui a été pensé pour la concurrence dès le début. Au contraire Python est un langages plus ancien qui, malgré de nombreux efforts récents dans ce domaine, reste plus complexe lorsqu’il s’agit d’écrire un scraper concurrent.

Il y a d’autres avantages à utiliser Go, mais ce sera l’objet d’un autre article !

Installez Go

J’ai déjà réalisé un petit tuto sur l’installation de Go sur Ubuntu.

Si vous souhaitez installer l’environnement sur une autre plateforme, référez-vous à la doc officielle.

Un scraper concurrent simple

Notre scraper se contente d’ouvrir une liste de pages web que nous lui donnons en amont et de vérifier qu’il obtient bien un code HTTP 200 (signe que le serveur a retourné la page HTML sans erreur). Pas de parsing HTML ici, le but étant de se focaliser sur la performance liée aux accès réseau. A vous d’écrire la suite de votre scraper !

Code final


/*
Open a series of urls.

Check status code for each url and store urls I could not
open in a dedicated array.
Fetch urls concurrently using goroutines.
*/

package main

import (
    "fmt"
    "net/http"
)

// -------------------------------------

// Custom user agent.
const (
    userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) " +
        "AppleWebKit/537.36 (KHTML, like Gecko) " +
        "Chrome/53.0.2785.143 " +
        "Safari/537.36"
)

// -------------------------------------

// fetchUrl opens a url with GET method and sets a custom user agent.
// If url cannot be opened, then log it to a dedicated channel.
func fetchUrl(url string, chFailedUrls chan string, chIsFinished chan bool) {

    // Open url.
    // Need to use http.Client in order to set a custom user agent:
    client := &http.Client{}
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("User-Agent", userAgent)
    resp, err := client.Do(req)

    // Inform the channel chIsFinished that url fetching is done (no
    // matter whether successful or not). Defer triggers only once
    // we leave fetchUrl():
    defer func() {
        chIsFinished <- true
    }()

    // If url could not be opened, we inform the channel chFailedUrls:
    if err != nil || resp.StatusCode != 200 {
        chFailedUrls <- url
        return
    }

}

func main() {

    // Create a random urls list just as an example:
    urlsList := [10]string{
        "http://example1.com",
        "http://example2.com",
        "http://example3.com",
        "http://example4.com",
        "http://example5.com",
        "http://example10.com",
        "http://example20.com",
        "http://example30.com",
        "http://example40.com",
        "http://example50.com",
    }

    // Create 2 channels, 1 to track urls we could not open
    // and 1 to inform url fetching is done:
    chFailedUrls := make(chan string)
    chIsFinished := make(chan bool)

    // Open all urls concurrently using the 'go' keyword:
    for _, url := range urlsList {
        go fetchUrl(url, chFailedUrls, chIsFinished)
    }

    // Receive messages from every concurrent goroutine. If
    // an url fails, we log it to failedUrls array:
    failedUrls := make([]string, 0)
    for i := 0; i < len(urlsList); {
        select {
        case url := <-chFailedUrls:
            failedUrls = append(failedUrls, url)
        case <-chIsFinished:
            i++
        }
    }

    // Print all urls we could not open:
    fmt.Println("Could not fetch these urls: ", failedUrls)

}


Explications

Ce code est un peu plus long que ce que nous aurions pu obtenir avec un langage comme Python, mais comme vous le voyez cela reste tout à fait raisonnable. Ici nous avons affaire à un langage statique et bien entendu déclarer ses variables prend un peu de place. Mais mesurez le temps d’exécution de ce programme et vous verrez que la récompense est au rendez-vous !

Nous avons pris 10 urls au hasard pour l’exemple.

Ici les mots-clés magiques nous permettant de faire de la concurrence sont go, chan et select:

  • go permet de créer une nouvelle goroutine, c’est à dire que fetchUrl sera à chaque fois exécutée dans une nouvelle goroutine concurrente.
  • chan est le type représentant un channel. C’est par ces channels que l’on va communiquer entre goroutines (main étant en elle-même aussi une goroutine).
  • select ... case est un switch ... case dédié à la réception des messages envoyés via les channels. On ne passe à la suite du programme que lorsque toutes les goroutines en cours d’exécution ont envoyé un message (ici soit pour dire que le fetching de l’url en cours est fini, soit pour dire que le fetching a échoué).

On aurait pu ne créer aucun channel pour ce scraper, c’est à dire se contenter de créer des goroutines et ne pas attendre d’informations en retour de leur part (si par exemple chaque goroutine finissait en stockant le résultat en base de données). Dans ce cas là il est tout à fait possible que notre goroutine principale main se termine alors que d’autres goroutines n’auront pas encore fini de s’exécuter (ce qui n’est pas forcément un problème puisque Go laisse s’exécuter toutes les goroutines, y compris si le main s’est arrêté). Mais en pratique dans la vie réelle il est presque toujours nécessaire d’utiliser les channels afin de faire dialoguer nos goroutines.

Pensez à limiter la vitesse !

Ici la vitesse maximum est recherchée, notamment parce que nous scrapons des urls toutes différentes. Cependant si vous scrapez plusieurs fois la même url (dans le cas du fetching d’une API externe par exemple), vous serez certainement contraint de ne pas dépasser un certain nombre de requêtes concurrentes par secondes. Pour cela la mise en place d’un compteur est nécessaire (objet peut-être d’un prochain article !).

Bon scraping !

Also available in English | También existe en Español
Installer Go (Golang) 1.9 sur Ubuntu 17.10

Voici un petit aide-mémoire pour ceux qui souhaitent installer Go (1.9) sur leur machine Ubuntu (17.10). Pour rappel, Go est un langage compilé, donc pas besoin d’installer Go sur la machine sur laquelle tournera votre application.

Mise à jour des dépôts et des correctifs de sécurité, au cas où :

sudo apt-get update
sudo apt-get -y upgrade

Téléchargement et installation de Go :

sudo curl -O https://storage.googleapis.com/golang/go1.9.linux-amd64.tar.gz  # Téléchargement de l'archive. Changez le nom de l'archive pour une autre version de Go ou une autre architecture système
sudo tar -xvf go1.9.linux-amd64.tar.gz  # Extraction de l'archive
sudo mv go /usr/local  # On déplace les binaires vers /usr/local
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile  # On met à jour notre profile bash pour que Go soit dans le PATH
source ~/.profile  # Actualise le profile

A ce stade, Go est installé ! Maintenant créez votre projet et initialisez les variables d’environnement :

mkdir $HOME/mon_projet
mkdir $HOME/mon_projet/src
mkdir $HOME/mon_projet/src/mon_appli
export GOPATH=$HOME/mon_projet

Puis créez votre appli :

vim $HOME/mon_projet/src/mon_appli/mon_appli.go

Contenant le code suivant :

package main

import "fmt"

func main() {
    fmt.Printf("hello world\n")
}

Compilez l’application :

go install mon_appli

Un executable a été généré dans un nouveau dossier bin. Exécutez-le :

$HOME/mon_projet/bin/mon_appli

Vous devriez obtenir :

hello world

Pour comprendre les différences entre go install, go build, et go run c’est par ici. Et si vous ne souhaitez pas/pouvez pas installer Go sur votre machine, jetez un coup d’oeil à cette image Docker.

Enjoy !

Also available in English | También existe en Español