L’Autorité de régulation des communications électroniques et des postes (Arcep) est une autorité administrative indépendante chargée de réguler les communications électroniques et les postes en France. Depuis juillet 2018, les 4 opérateurs mobiles français sont tenus de publier sur leur site une liste d’antennes relais en maintenance (comprendre qui ne fonctionne pas actuellement).

Cette obligation de publication est introduite par autant de décisions qu’il y a d’opérateurs. Pour Free, c’est la décision 2018-0681 qui stipule la chose dans une section intitulée Obligation de transparence.

Le titulaire est tenu, au plus tard le 1er juillet 2018, de publier et de maintenir à jour sur son site Internet, dans un format électronique ouvert et aisément réutilisable, la liste des stations de base qui ne fournissent pas de service de radiotéléphonie mobile ou de service d’accès mobile à très haut débit pour cause de maintenance ou de panne.

Free Mobile publie cette information sur une page dédiée, permettant la recherche d’une éventuelle panne maintenance par code postal et par le biais d’un fichier CSV (un format ouvert et aisément réutilisable). Chez SFR, il y a une jolie page nommée arceptest.html. Bouygues a choisi de publier ces informations sur un sous-domaine antennesindisponibles (mais au format XLS). Orange publie pour sa part un fichier CSV.

Une solution originale de transparence et de régulation

J’ai plusieurs remarques concernant cette mesure de régulation de l’Arcep. Tout d’abord, je trouve très intéressant et je salue le fait que l’obligation réside dans la publication par l’opérateur lui-même plutôt que par la transmission de l’information au régulateur. Premièrement, on rend ainsi l’information disponible pour d’autres personnes et on responsabilise l’opérateur. Deuxièmement, on évite le cas où le régulateur est en possession de l’information mais ne la diffuse pas.

Des améliorations possibles

Je regrette que la formulation de l’obligation de publication soit trop floue. La formulation dans un format électronique ouvert et aisément réutilisable reprend une formulation classique de la Loi pour une République numérique. L’obligation ne stipule pas un modèle de données, ainsi les informations publiées et les noms de colonnes varient selon les opérateurs. Enfin, le point le plus embêtant est que l’obligation porte sur une publication des indisponibilités à l’instant T sur les antennes relais. Il aurait été intéressant d’avoir un historique pour effectuer des analyses sur la répétition de pannes sur des zones géographiques, des délais de réparation, des pannes à répétition etc. Un tel historique peut être construit, mais c’est à la charge de qui le désire. J’ai fait cet exercice pour Free Mobile en automatisant la récupération des fichiers CSV toutes les heures et je rends disponible les données récoltées.

La Société Nationale des Chemins de Fer français (SNCF) est l’entreprise ferroviaire publique française. Le coeur de métier de la SNCF est d’exploiter un réseau ferroviaire et de transporter des passagers. Les chiffres clés sont impressionnants : 15 000 trains commerciaux arpentent le réseau ferré tous les jours, permettant à 4 millions de clients de se déplacer. Souvent décriée pour ses problématiques opérationnelles et sa difficulté à transmettre des informations aux voyageurs, la SNCF s’est notablement améliorée depuis plusieurs années. Cet effort de diffusion, de transparence et d’amélioration continue est visible sur le portail open data de la SNCF data.sncf.com.

Sur ce portail open data, on retrouve des statistiques de régularité au mois et par type de transport (TGV, Intercités, Transilien, TER). Ces données ont un intérêt pour évaluer l’évolution de la qualité de service au fil des années. Je regrette toutefois l’agrégation assez large : au mois / par région / par axe. Les voyageurs sont plus soucieux des régularités aux heures de pointe et durant les jours ouvrés. Espérons que cela évolue vers un découpage par tranches horaires et par jour. Ces jeux de données sont des incontournables étant donné l’activité commerciale de transports de voyageurs de la SNCF.

Toujours sur la régularité mais dans une temporalité différente, la SNCF propose depuis quelques mois un rapport quotidien sur la régularité des différentes lignes et axes sur la journée d’hier. Cette application est nommée Mes trains d’hier. Les faits majeurs sont relatés, expliquant une mauvaise performance. Je regrette la non disponibilité de ces données en open data et l’impossibilité de choisir une date antérieure.

Une thématique souvent absente sur les portails open data mais présente côté SNCF est celle des jeux de données se rapportant aux ressources humaines, aux salariés, mouvements sociaux, congés, accidents du travail. On retrouve ainsi des jeux de données décrivant les nationalités, les genres, les rémunérations, les journées perdues lors de mouvements sociaux. Ce sont des informations que l’on retrouve dans les rapports annuels des grands groupes mais je salue le fait d’en faire des jeux de données à part entière.

Sur la transparence pure, je relève 2 jeux de données très intéressants : les courriers institutionnels entre son équipe dirigeante et les représentants élus de l’État et des collectivités locales et les indicateurs de Responsabilité Sociétale de l’Entreprise pour le groupe SNCF Réseau depuis 2016.

Notons que ces jeux de données ont été diffusés dans un premier temps sous une licence de réutilisation non homologuée. La situation a été rectifiée en juillet 2019, les données sont dorénavant diffusées sous une licence ODbL.

Enfin, je termine cet article avec les jeux de données qui m’amusent le plus :

• La liste des 9500 abréviations utilisées (vraiment ?)
• Les objets trouvés (et restitués !), mis à jour 3 fois par jour, comportant une catégorie Articles d’enfants, de puériculture.

Cet article est un rapide tour d’horizon des jeux de données disponibles en ligne. En août 2019, plus de 215 jeux de données sont publiés sur ce portail. Les thématiques majeures non abordées dans cet article sont l’infrastructure ferroviaire, les services aux voyageurs, la billetique et les gares.

It’s the end of June and I want to take a step back and reflect on my open source contributions since the beginning of the year. I’ve made 770 public commits on GitHub in the first semester.

I’m working at Etalab, the French government administration in charge of data policy and I’m involved in the Public Interest Entrepreneurs program (hiring talents to work in the administration). 95% of the code I work on is open source. This is a huge privilege and I love it. I get to talk about my work, collaborate with people and help other open source enthusiasts.

Main projects

Here are the main projects I’ve been contributing to (in term of commits):

• etalab/schema.data.gouv.fr: the website schema.data.gouv.fr collects, validates and displays schemas for open data datasets
• entrepreneur-interet-general/bulletins: a weekly retrospective tool for multiple projects or teams I developed for the Public Interest Entrepreneurs program
• entrepreneur-interet-general/site-eig: the Jekyll website of the Public Interest Entrepreneurs program
• etalab/data-codes-sources-fr: an initiative to automatically collect metadata about code repositories published by public administrations. I blogged about it.
• AntoineAugusti/table-schema-to-markdown: a Python library to convert a TableSchema file (describing a tabular file schema) to a Markdown documentation
• etalab/csv-gg: a VueJS application to generate forms from and validate against a Table Schema
• AntoineAugusti/vacances-scolaires and AntoineAugusti/vacances-scolaires-france: a dataset and a Python library about French school holidays
• DISIC/politique-de-contribution-open-source: the French open source contribution policy
• etalab/vuepress-theme-gouv-fr: a VuePress theme for the French administration
• Repos to automatically collect data: AntoineAugusti/tweets-rerb about the RER B transit line, AntoineAugusti/antennes-free outages for mobile antennas, AntoineAugusti/glyphosate about uses of pesticide and snosan-tools/avurnavs-fichiers for navigational warnings in France.

Overall I’ve contributed to more than 50 public repositories.

Data extraction

I extracted this data thanks to Google BigQuery, which provides a public dataset storing GitHub events. This was the best way I found to extract my public activity on GitHub. Unfortunately GitHub doesn’t provide a way to get this through the API (at the people level) or through a personal export. Here is the SQL request used to extract only my public commits:

SELECT
  repo.name,
  count(1) as nb
FROM (
  TABLE_DATE_RANGE([githubarchive:day.], 
  TIMESTAMP('2019-01-01'), 
  TIMESTAMP('2019-06-31')
))
WHERE actor.login = 'AntoineAugusti'
  and type = 'PushEvent'
GROUP BY repo.name

Community

These open source contributions have been a great opportunity to work with others. Open source lets public administrations interact with other administrations, companies, nonprofits and other governments on a daily basis. It’s been a privilege to answer questions, explain how things work and inspire others. Of course I’ve relied on many open source projects and have been helped a lot by other contributors.

Thanks to all the community, see you online for the next semester!

Lately, I’ve had the chance to discover how to leverage the caching of HTTP responses from proxied servers using NGINX and the proxy_cache configuration directives. The web application I’m talking about is dedicated to show sales of properties in France, recently made available in open data. This represents 15 million sales of real estate (houses, flats, lands, forests etc.) in 5 years. The application, realised by Etalab, gets a national press coverage because it’s hosted on an official government domain and was introduced by the Minister of Public Action and Accounts of France.

The web application is composed of a Python backend, talking to a PostgreSQL database with a standard geographical interface with filters and various zoom levels. You can see a demo of the first version of the application in video and browse the code created by Marion Paclot. Regarding traffic, NGINX handles a traffic of 2500 requests/minute during the day with peaks up to 5000-6000 requests/minute, the analytics are available publicly. Knowing people mainly browse their neighbourhood, it’s important to keep areas with a high population density in cache.

The goal was to keep up with this load with a single server of 8 cores and 32 Go of RAM. NGINX delivers this thanks to its proxy cache. We can serve the application with a load average of a 1-3 and an average RAM usage of 3 Go and 8 Go of proxy cache size. You’ll find the commented NGINX configuration below

# Define a cache of up to 10 Go, with files up to 10 Mo. Files that have
# been created more than 2 days ago will be deleted.
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=dvf:10m max_size=10g inactive=2d use_temp_path=off;
# Default key example: md5(GETapp.dvf.etalab.gouv.fr/api/mutations/75101/000AI/from=01-01-2014&to=30-06-2018)
proxy_cache_key "$request_method$host$request_uri";

# Rate limiting by IP, up to 50 Mo of storage and limited to 10 requests per second
limit_req_zone $binary_remote_addr zone=hit_per_ip:50m rate=10r/s;

server {
  server_name app.dvf.etalab.gouv.fr;
  root /srv/dvf/static;

  # Serve directly geojson files with a browser cache of 30 days
  location ~ ^/(cadastre|donneesgeo) {
    expires 30d;
    access_log off;
    add_header Cache-Control "public";
  }

  # Cache static files (index.html / *.js) only 30s in the proxy
  # cache and browser cache of 1 minute to be able to deploy
  # quickly changes.
  location / {
    expires 1m;
    add_header Cache-Control "public";

    proxy_cache dvf;
    proxy_cache_valid 200 30s;
    # Change the default query to drop the query parameters. News sites
    # often add query parameters to the index we are not interested in
    # and could bust our cache
    proxy_cache_key "$request_method$host$request_filename";
    include includes/dvf_proxy.conf;
  }

  # The API tells which sales happened for a specific geographic area
  # between 2 dates.
  # This where we need to talk to Python + PostgreSQL. Keep API responses
  # in cache for 1 day and set the browser cache to 12 hours.
  # Allow a burst of up to 50 requests / second, but requests will be
  # queued to respect the max of 10 requests / second.
  location /api {
    expires 12h;
    add_header Cache-Control "public";

    limit_req zone=hit_per_ip burst=50 nodelay;
    limit_req_status 429;

    proxy_cache dvf;
    proxy_cache_valid 200 1d;
    include includes/dvf_proxy.conf;
  }

  listen 443 ssl http2; # managed by Certbot
  ssl_certificate /etc/letsencrypt/live/app.dvf.etalab.gouv.fr/fullchain.pem; # managed by Certbot
  ssl_certificate_key /etc/letsencrypt/live/app.dvf.etalab.gouv.fr/privkey.pem; # managed by Certbot
  include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
  ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}
server {
  if ($host = app.dvf.etalab.gouv.fr) {
    return 301 https://$host$request_uri;
  } # managed by Certbot

  server_name app.dvf.etalab.gouv.fr;
  listen 80;
  return 404; # managed by Certbot
}

And the include/dvf_proxy.conf file, which proxies requests to Gunicorn, the Python server:

add_header X-Proxy-Cache $upstream_cache_status;
    
add_header X-Frame-Options SAMEORIGIN;
add_header Content-Security-Policy "frame-ancestors 'self'";
add_header X-Content-Security-Policy "frame-ancestors 'self'";

proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_pass http://127.0.0.1:8000;

This article is written in English but may be of particular interest to French civil servants. If you’ve got troubles understanding English, please email [email protected].

Lately, I wondered if it was possible to know about how people working for the French government produce, publish and contribute to open source code. Having a complete picture is nearly impossible, but I could start with something: analysing commits pushed on GitHub by people who used a @*.gouv.fr email address.

Gaining knowledge about this subject enables a lot of things: knowing where code is published, meeting fellow developers, building a list of commonly used software, establishing a list of open source software the government contributes to and a lot more.

Methodology

I used Gh Archive which provides a compressed log file for every hour since 2015-01-01 with GitHub events’ API. Each log file contains all public events (events for private repositories are not available there) which happened on GitHub during this hour. GitHub provides 20+ event types (opening a pull request, writing a comment on an issue, pushing a commit etc). These logs are quite huge: for example it was 500 GB (compressed) for 2015 and 1.07 TB (compressed) for 2018.

I downloaded and processed these log files from 2015-01-01 until 2019-03-31. The total number of rows was 1,523,732,038 (1.5 billion events). I only kept rows when a commit was pushed (the PushEvent event) and the main author committed with a @*.gouv.fr e-mail address. This means that we have a row every time someone commits to a public GitHub repository with a @*.gouv.fr email address between 2015-01-01 and 2019-03-31.

Limits

Getting a list of all commits done by people coding for the French government is incredibly hard, for a number of reasons:

• A majority on contributions are not made on GitHub or are not even available on the Internet;
• Some developers use their personal laptop with Git already configured with their personal email address and don’t switch to their government one when coding at work;
• I know that civil servants don’t always have a @*.gouv.fr e-mail address;
• A very few amount of people commit using their @*.gouv.fr e-mail address for now, even if it is recommended in the French government open-source contribution policy (it was recently published in February 2018).

With these important limits in mind, let’s look at the data.

Analysis

Data: we have a row every time someone commits to a public GitHub repository with a @*.gouv.fr e-mail address between 2015-01-01 and 2019-03-31. There is a total of 24,989 commits in the dataset (only).

First, let’s look at the number of commits by month since 2015.

Then, let’s look at the number of unique committers by month. I’m glad to notice an upward trend but it’s also very clear that the data is missing a lot of people. According to the data, only 66 people with a @*.gouv.fr e-mail address did at least a commit in January 2019 which is way less than the reality.

When do people commit during the week? It was funny to spot a slight downward trend from Monday to Friday. Some people push commits during the weekend but 10x less than during the workweek.

What time of the day do people push commits? The hour is plotted in UTC but Metropolitan France is UTC+1 or UTC+2. I’m glad to notice a sharp drop at lunch time around noon / 1pm. Eating is super important in France ?.

What’s the most common commit messages? I bet on something around wip / fix / Initial commit but I was a bit surprised. To spot people who’re doing a lot of commits, I added a second column with the unique number of authors. We can clearly see people who’re using GitHub’s UI to do a commit: Update README.md or Add files via upload.

Then, I’ve looked at commit repartition by domain name. I know, it’s far away from the reality but I still had to make a table. I kept only major email domains, defined by the total number of commits recorded.

Last but not least, I’ve looked at the total number of commits done in a GitHub organisation and the number of unique committers who’ve contributed in this organisation. The first one is the blank organisation: when people contribute to their github.com/[username] or github.com/[someone] where username and someone are individual users, not organisations.

Finally, I’ve looked at contributions to open source projects which are not published by government. I was glad to found contributions to organisations like mozilla, opendnssec, sagemath, krb5, hibernate, legilibre, qgis, rstudio, TheHive-Project or openstack (in no particular order). The French government open-source contribution policy lets people contribute to open source code during work hours, with their own name and using their government email address. I hope it will be easier to collect these contributions in the future.

Doing the same

The code I wrote to extract the data and the dataset itself is available on GitHub and on data.gouv.fr with open source licences. I used standard UNIX programs (wget / gunzip / jq), Python and Metabase. If you feel like doing something like this yourself or using the data, feel free to do so! I’d love to hear about it.

What’s next

This is a personal project but I hope it’s just the beginning. I know how frustrating it is to have numbers so low to show for now and how far from the reality this is. I wrote in a previous article (in French) about how I built a list of repositories and organisations where the public administration publishes code. I’m very interested by these topics so I will continue to work on them and write about it.

In order to move forwards, a few things:

• If you’re working for the French government, use your work email address when publishing or contributing to open source code. Learn how to set your email address in Git;
• If you’re a public administration, register where you publish your code in this file;
• If you’re writing or contributing to open source software, first thanks a lot, and please continue to do so;
• If you’ve got comments, questions or ideas, send an email to [email protected].

I’d like to thank my colleagues Bastien Guerry and Laurent Joubert.

En France, les codes sources sont considérés comme des documents administratifs qui sont communicables, publiables en ligne et réutilisables (article L300-2 du code des relations entre le public et l’administration). Ainsi, les administrations, collectivités territoriales, établissements publics et entreprises chargées d’une mission de service public publient les codes sources de leurs logiciels (avec toutefois des réserves comme lorsque ceci concerne la défense nationale, la sécurité, la monnaie etc. voir article L311-5). On peut donc retrouver de nombreux logiciels publiés par la fonction publique sur des plateformes comme GitHub ou Gitlab.

La DINSIC (direction interministérielle du numérique et du système d’information et de communication de l’État) publie par ailleurs une politique de contribution aux logiciels libres qui guide les administrations et les agents lorsqu’ils publient ou contribuent à des logiciels libres.

Je vous propose dans cet article de mettre en évidence quelques chiffres clés des logiciels publiés par la fonction publique en France.

Données utilisées

Obtenir une liste des organisations utilisées par la fonction publique française sur les plateformes de partage de code n’est pas une mince affaire. Je me base sur la liste des organisations que l’on retrouve sur un répertoire de la DINSIC consacré ainsi que la liste présente sur le site government.github.com pour la France. Pour des raisons de simplicité, je ne conserve que les organisations créées sur GitHub, cette plateforme représentant la quasi exclusivité des publications de dépôts de code des organismes publics français.

Ce travail de récupération des données (grâce à des appels à l’API de GitHub et du Python) et les données se trouvent dans un répertoire GitHub que j’ai publié : AntoineAugusti/data-codes-sources-fr. Les analyses se basent sur les données à la date du 12 janvier 2019.

On dénombre un total de 1531 répertoires dans 53 organisations. Attention, une administration peut avoir plusieurs organisations. C’est par exemple le cas de l’ANSSI (Agence nationale de la sécurité des systèmes d’information), pionnière de l’open source, qui compte 4 organisations (ANSSI-FR, clipos, clipos-archive, wookey-project).

Organisations les plus populaires

La popularité d’une organisation est difficile à évaluer. J’ai choisi arbitrairement de prendre la somme des stars, l’équivalent des favoris sur GitHub. Voici un tableau récapitulatif pour le top 20 des organisations.

La sécurité est à l’honneur ! En effet, le top 2 correspond à l’équipe sécurité informatique du CEA (Commissariat à l’énergie atomique et aux énergies alternatives) puis l’ANSSI (Agence nationale de la sécurité des systèmes d’information).

Langages les plus populaires

Alors, à votre avis, quels sont les langages principaux des répertoires des organismes français ? Cobol, Fortran ? Vous êtes bien moqueurs, et loin de la réalité.

Un tiers des répertoires publiés le sont en JavaScript ou en Python, ce qui correspond à la popularité de ces langages actuellement. 216 répertoires ont un langage inconnu. Pour avoir regardé quelques exemples, je constate souvent que ce sont des répertoires qui contiennent quasi exclusivement des fichiers textes (en Markdown, RST ou TXT), utilisés comme répertoires de documentation ou comme wiki.

Licences utilisées

Le top 1 n’est pas une bonne nouvelle. Point de méthode : la licence est détectée par GitHub, à l’aide de la librairie Ruby Licensee. J’ai tenté d’en savoir plus, voici ce qui explique ce triste résultat :

• un nombre important de projets ne comporte pas de fichier de licence (la bonne pratique est de mettre ceci dans un fichier LICENSE) ;
• certains projets mentionnent la licence dans le README ;
• d’autres projets utilisent les licences CeCILL ou la Licence Ouverte (licences introduites par la France), dans des fichiers nommées CeCILL.txt ou LO.md et qui ne sont donc pas reconnus.

Concernant les licences non détectées, la librairie utilisée par GitHub ne reconnait pas encore les licences CeCILL ou la Licence Ouverte, ce qui peut expliquer une part importante de licences classées dansOther.

Il faut noter que la liste des licences que peuvent utiliser les organismes publics français est restreinte et définie par décret. Ces licences sont listées sur une page de data.gouv.fr.

Je remarque qu’il faut donc progresser du côté des licences utilisées lors de la publication des répertoires. L’absence de licence ou une licence non adéquate empêche la réutilisation du logiciel.

Création des répertoires au cours du temps

Bon nombre de répertoires voient le jour tous les mois. Par exemple, en 2018, 45 répertoires ont été créés en moyenne par mois. Le pic de septembre 2018 s’explique par la publication du projet clipos-archive par l’ANSSI comportant 101 répertoires.

La suite

Cette courte analyse relève d’une initiative personnelle. Espérons qu’un des objectifs de l’année 2019 soit d’encourager et de faire la promotion des publications de codes sources des organismes publics français. L’idéal étant de pouvoir cataloguer plus d’organismes, augmenter la qualité de publication des répertoires et avoir régulièrement un retour sur la production de logiciels libres par la fonction publique française.

In this blog post, I’ll explain how to leverage Netlify and GitHub to create a REST API, serving JSON, without any infrastructure and for free. Netlify is amazing at deploying projects with continuous integration, a build step, static hosting behind a CDN and with automatic HTTPS support thanks to Let’s Encrypt. I’m using GitHub as my go-to hosted version control system, but you can use Gitlab or Bitbucket if you’d like.

Our project has some constraints:

• The REST API will only be able to serve content, not create, update or delete things (we only have static hosting and not a server-side language) ;
• You should have a reasonable amount of files to serve (a few hundreds);
• You should respect Netlify’s Terms of Service. Quotas for free accounts: 100 GB / month of bandwidth, 100 GB of storage.

Example: an API for bank holidays

I’ll use a real-world example to explain things: we’re going to build a REST API for bank holidays. Basically, for a given year, we’ll tell which days are bank holidays. Here is the final GitHub repository.

First, we need the raw data. In my case, I’ll use a CSV dataset for French bank holidays. During Netlify’s build step, we’ll create all the required files that will be served by our API. In our case, we want to create one JSON file per year, which will contain the bank holidays of that year. Netlify supports a handful of languages for the build phase, I’ve used Python 3.6 (the desired Python version is specified in the file runtime.txt). My build.py file downloads CSV files, convert them in JSON and store a file per year.

We now already have a working API, that exposes transformed JSON files. You could already access these files, by using a URL like /data/2019.json. Since we’re building a REST API, we want to expose meaningful URLs. To do this, we’ll leverage Netlify’s redirect rules. You can see my redirect rules in the _redirects file. Thanks to this, the final endpoint will be /api/2019, which is far better. Since our endpoints will most likely not change, I’ve used Netlify’s custom HTTP headers to set Cache-Control HTTP headers to instruct clients to cache the received data. You can see my rules in the _headers file.

Demo for French bank holidays in 2019: https://jours-feries-france.antoine-augusti.fr/api/2019

Takeaway

We’ve used the build step of Netlify to create our desired world for our API. Now Netlify takes care of hosting it with a custom domain, providing and renewing SSL certificates. All in 35 lines of Python. Not bad.

By default Netlify will rebuild your project every time you push a commit. You could perform builds more often by using webhooks.