Alexis Seigneurin

Serverless technologies have become prevalent but they lack some tooling to make them easier to work with. The Serverless Framework comes to the rescue in the form of a CLI that automates deployment tasks. This post will be an introduction to using this tool.

When you start doing some Machine Learning, you go through a batch-oriented process: you take a dataset, build a Machine Learning model from this data, and use the model to make some predictions on another dataset. Then, you want to apply this process to streaming data, and this is where it can get confusing! Let’s see what you can do in streaming and what you cannot do.

I wrote quite a few tutorials about Kafka, so now is the time to look at more advanced problems. In this post, we will see how to perform windowed aggregations and how to deal with late events.

We have been writing a lot of code so far to consume a stream of data from Kafka, using Kafka’s Java client, Kafka Streams, or Spark. In this post, we will see how we can use KSQL to achieve similar results.

In the previous posts, we went through how to consume data from Kafka with the low-level Java client, with Kafka Streams, and with Spark Structured Streaming. In this post, we will run a quick experiment to see what latency each library/framework can achieve.

This is the post number 8 in this series where we go through the basics of using Kafka. So far, we have been using the Java client for Kafka, and Kafka Streams. This time, we are going to use Spark Structured Streaming (the counterpart of Spark Streaming that provides a Dataframe API).

This is the seventh post in this series where we go through the basics of using Kafka. We saw in the previous post how to build a simple Kafka Streams application. We will see here how to use a custom SerDe (Serializer / Deserializer) and how to use Avro and the Schema Registry.

This is the sixth post in this series where we go through the basics of using Kafka. In this post, instead of using the Java client (producer and consumer API), we are going to use Kafka Streams, a powerful library to process streaming data.

This is the fifth post in this series where we go through the basics of using Kafka. We saw in the previous post how to produce messages in Avro format and how to use the Schema Registry. We will see here how to consume the messages we produced.

This is the fourth post in this series where we go through the basics of using Kafka. We saw in the previous posts how to produce and consume data in JSON format. We will now see how to serialize our data with Avro.

This is the third post in this series where we go through the basics of using Kafka. We saw in the previous posts how to produce and consume JSON messages using the plain Java client and Jackson. We will see here how to create our own serializers and deserializers.

This is the second post in this series where we go through the basics of using Kafka. We saw in the previous post how to produce messages. We will see here how to consume the messages we have produced, how to process them and how to send the results to another topic.

Kafka 2.0 just got released, so it is a good time to review the basics of using Kafka. I am going to focus on producing, consuming and processing messages or events. I don’t plan on covering the basic properties of Kafka (partitioning, replication, offset management, etc.) - these are well covered in the documentation of Kafka.

If you are running a Spark Standalone cluster behind a firewall (let’s say it is running on Amazon AWS and your EC2 instances don’t have public IP addresses), you might have issues accessing the UI of your cluster, especially because each worker has its own UI, making it difficult if not impossible to reroute all the ports using only SSH tunnels.

I am a Software Engineer and I like when the tools I use help me through my day of work, not when they make it complicated. This goes through the choice of tools that I use, and how I configure them. In this post, I thought I would share what are “my essentials” when I use my Mac…

This is the second post of a 2-part introduction to Kotlin, a programming language for the JVM. If you are a Java developer, you should read this and, like I did a few months ago, consider the option of learning Kotlin.

This post is a 2-part introduction to Kotlin, a programming language for the JVM. If you are a Java developer, you should read this and, like I did a few months ago, consider the option of learning Kotlin.

This is the third and final post in this series of posts in which I explain why, for our application, we had to transition from Kafka Streams to an implementation using plain Kafka Consumers. In this post, I will explain how we re-implemented the application.

This is the second post in this series of posts in which I explain why, for our application, we had to transition from Kafka Streams to an implementation using plain Kafka Consumers. In this post, I will explain how we made the first implementation using Kafka Streams and what problems we encountered.

This is a post in 3 parts in which I explain how we started a project on Kafka Streams, and why we had to stop using this library because it had a scalability issue. I took a lot of inspiration from Streams, though, and I will explain how we re-implemented our application on top of plain Kafka Consumers.

I gave a talk at Kafka Summit NYC on May 8th, 2017.

In this post, I explore how you can leverage Parquet when you need to load data incrementally, let’s say by adding data every day. We will see how we can add new partitions to an existing Parquet file, as opposed to creating new Parquet files every day.

I recently worked on a project in which Spark was used to ingest data from text files. The team was struggling to read the files with acceptable performance. That lead me to analysing a few options that are offered to you when using Spark. I am reviewing them here.

Kafka Streams is a new component of the Kafka platform. It is a lightweight library designed to process data from and to Kafka. In this post, I’m not going to go through a full tutorial of Kafka Streams but, instead, see how it behaves as regards to scaling. By scaling, I mean the process of adding or removing nodes to increase or decrease the processing power.

In a previous post, I demonstrated how to consume a Kafka topic using Spark in a resilient manner. The resiliency code was written in Scala. Now, I want to leverage that Scala code to connect Spark to Kafka in a PySpark application. We will see how we can call Scala code from Python code and what are the restrictions.

Kafka and Spark Streaming are two technologies that fit well together. Both are distributed systems so as to handle heavy loads of data. Making sure you don’t lose data does not come out-of-the-box, though, and this post aims at helping you reach this goal.

This post is the third and last post in a series in which we learn how to send messages in the Avro format into Kafka so that they can be consumed by Spark Streaming. As a reminder there are 3 posts:

This post is the second post in a series in which we will learn how to send messages in the Avro format into Kafka so that they can be consumed by Spark Streaming. As a reminder there will be 3 posts:

This post is the first in a series of posts in which we will learn how to send messages in the Avro format into Kafka so that they can be consumed by Spark Streaming. There will be 3 posts:

I participated to a project for a leading insurance company where I implemented a Record Linkage engine using Spark and its Machine Learning library, Spark ML. In this post, I will explain how we tackled this Data Science problem from a Developer’s point of view.

Le Spark Summit - la conférence officielle autour du framework Apache Spark - se tenait à Amsterdam du 27 au 29 octobre. Votre serviteur était présent les 28 et 29 octobre. Résumé des évènements.

I’ve given a talk about how to take Data Science projects to production thanks to the help of Software Developers.

J’ai récemment mis en place un bot pour tweeter plusieurs fois les posts publiés sur le blog d’Ippon (Cf. fil Twitter d’Ippon). Cet outil (rss2twitter) repose sur deux containers Docker. Pour gérer ces containers, un outil d’orchestration est pratique. Rapide présentation de deux challengers : Docker Compose (anciennement Fig) et Crane.

Dans mon post Spark vs Command line tools, je comparais les performances de Spark et d’outils du shell pour traiter des résultats de parties d’échec. Le volume de données était très réduit (4,6 Go) et un seul nœud était utilisé. Spark étant un outil dédié au traitement distribué, l’exercice atteignait ses limites. Restait donc à étudier les performances sur des volumes plus importants et en cluster.

Il y a quelques jours, un post d’Adam Drake a refait surface sur Twitter : Command-line tools can be 235x faster than your Hadoop cluster. Adam explique qu’il a reproduit un traitement Hadoop avec des outils de ligne de commande (find, awk…) multipliant ainsi le débit de traitement par 235. J’ai cherché à reproduire cette comparaison avec Spark.

Spark permet de manipuler d’importants volumes de données en utilisant une API de bas niveau. Pour simplifier l’exploration des données, Spark SQL offre une API de plus haut niveau avec une syntaxe SQL. Spark SQL permet ainsi de réaliser, très rapidement, de nombreuses opérations sans écrire de code.

Cette semaine, j’ai été interviewé par Fabrice Croiseaux et Antoine Detante pour le podcast Nipdev. Pendant une heure, nous avons parlé de Spark.

J’ai présenté Apache Spark à diverses occasions récemment :

Spark permet de traiter des données qui sont figées à un instant T. Grâce au module Spark Streaming, il est possible de traiter des flux de données qui arrivent en continu, et donc de traiter ces données au fur et à mesure de leur arrivée.

J’étais à Codeurs en Seine aujourd’hui pour la deuxième édition de cette conférence pour développeurs basée à Rouen. Cette édition a accueilli 350 développeurs.

Dans les précédents posts, nous avons utilisé Apache Spark avec un exécuteur unique. Spark étant un framework de calcul distribué, nous allons maintenant monter un cluster en mode standalone.

Nous avons vu dans le post précédent qu’Apache Spark permettait de réaliser des opérations d’agrégation sur l’ensemble des valeurs d’un RDD. Nous allons maintenant réaliser des agrégations ainsi que d’autres manipulations par clés.

Ansible est un excellent outil de provisioning. L’outil n’est a priori pas prévu pour déployer des applications bien que l’on soit fortement tenté de l’utiliser dans ce but. Ce post traite des problèmes que cela pose et d’une manière de les résoudre.

Dans le précédent post, nous avons utilisé l’opération Map qui permet de transformer des valeurs à l’aide d’une fonction de transformation. Nous allons maintenant découvrir l’opération Reduce qui permet de faire des aggrégations. Nous allons ainsi pouvoir faire du MapReduce de la même manière qu’avec Hadoop.

Spark est un outil permettant de faire du traitement de larges volumes de données, et ce, de manière distribuée (cluster computing). Le framework offre un modèle de programmation plus simple que celui d’Hadoop et permet des temps d’exécution jusqu’à 100 fois plus courts.

AngularJS, tout comme de nombreux frameworks Javascript récents, exploite le navigateur pour effectuer le rendu côté client. Les pages fournies par le serveur sont donc des coquilles vides. Les sites exploitant ces technologies sont donc très mal indexés par les moteurs de recherche.

Les slides de ma présentation sur les interfaces fonctionnelles à BDX.io sont en ligne.

Le vendredi 17 octobre se tiendra la première édition de BDX.io, une conférence pour développeurs à Bordeaux. Au programme, 40 talks sur des sujets du moment : on y parlera de langages (Java, Go, Clojure…), de développement Web (AngularJS, Web Components…), de déploiement (Docker), de bases de données NoSQL (Mongo…), de Machine Learning, et j’en passe. Bref, pour cette première édition, BDX.io fait bien les choses avec un programme très riche.

Le Breizh Camp 2014 est déjà terminé pour moi. Sur deux jours et demi, la conférence organisée sur le campus universitaire de Rennes a accueilli 250 personnes. Au programme, 80 talks, tous formats confondus (conférences, hands-on labs, tools in action, quickies) !

Ma présentation Vagrant pour les développeurs au BreizhCamp est en ligne:

Ma présentation Java 8 - Les interfaces fonctionnelles au BreizhCamp est en ligne:

Parce que le Devoxx ne parle pas que de Java, je voulais revenir sur le talk d’Arnaud Taffanel et de Marcus Eliasson sur la génèse du Crazyflie Nano, un quadricoptère de seulement 19 grammes.

Ma présentation Du dev à la prod avec Vagrant et Packer chez Ippon est en ligne:

Vous connaissez Vagrant ? Vagrant, c’est cet outil qui permet de démarrer des machines virtuelles avec une configuration donnée. Un très bon moyen de mettre au point et de diffuser des environnements de travail, et ce, de manière reproductible. Vagrant permet donc d’éviter le syndrome “works on my machine”.

Java 8 introduit le concept d’”interface fonctionnelle” qui permet de définir une interface disposant d’une unique méthode abstraite, c’est-à-dire une seule méthode ne possédant pas d’implémentation par défaut.

Security is tricky subject. In fact, we should never think we know about security. The way we store passwords in database is an example of how we might do things the wrong way. We may think storing the MD5 hash of a password, but this is very unsafe as an attacker could use a rainbow table to retrieve the password.

Data structures can evolve with time, either during the development of a project or between versions of the project. It is crucial to know which structure you are dealing with. In order to do that, you should store the version number of the data structure along with your data.