Format Parquet dans l'API Navixy Raw Data

Principaux enseignements

Les entreprises utilisant la télématique ont besoin d'un moyen d'analyser efficacement les données télématiques brutes, comme des dizaines de paramètres de véhicules, pour obtenir des informations opérationnelles plus approfondies.
Le format Apache Parquet est idéal pour traiter les grands ensembles de données IoT, offrant un stockage en colonnes, une compression et une évolution du schéma pour un traitement efficace.
Avec le nouveau paramètre "format", l'API de données brutes de Navixy prend désormais en charge Parquet, ce qui permet de rationaliser le traitement des données et d'accélérer les analyses.

Les données télématiques volumineuses nécessitent des solutions volumineuses. L'API de données brutes de Navixy est votre porte d'entrée vers un trésor de données brutes d'appareils IoT, surtout maintenant que Navixy prend en charge Apache Parquet pour traiter les données télématiques de manière plus efficace.

En tant que professionnel de la télématique, vous savez parfaitement que le traitement de vastes quantités de données provenant de flux à haute fréquence et d'archives historiques peut être fastidieux. Les formats de fichier traditionnels tels que le CSV sont souvent difficiles à gérer avec de grands ensembles de données, ce qui ralentit le traitement des données et nécessite beaucoup de stockage. Cela peut entraver l'accessibilité des données, ce qui retarde la prise de décisions et de connaissances critiques pour l'entreprise.

À ce stade, le format Parquet peut changer la donne en offrant une manipulation des données très performante, un traitement plus rapide et un stockage réduit pour les ensembles de données à grande échelle.

Poursuivez votre lecture pour découvrir pourquoi Parquet est important, comment il fonctionne avec l'API de données brutes de Navixy et pourquoi vous devriez vous y intéresser.

Parquet : le héros des formats de données volumineuses

Attendez, qu'est-ce que Parquet, me direz-vous ? Ne vous inquiétez pas, nous allons entrer dans le vif du sujet.

Pour mieux comprendre Parquet, vous pouvez le considérer comme le cousin plus cool et plus efficace du CSV. Il s'agit d'un format de fichier spécialement conçu pour les environnements big data, et il est désormais à votre portée grâce à l'API de Navixy.

Voici ce qu'il en est : Parquet n'est pas seulement un type de fichier, mais plutôt un outil qui facilitera l'accès à vos données et leur analyse.

Alerte au spoiler : si vous traitez des quantités massives de données IoT (et soyons honnêtes, qui ne le fait pas de nos jours ?), cela pourrait changer la donne pour vos opérations.

Pourquoi le format de fichier Apache Parquet peut-il être meilleur pour la télématique ?

Pour commencer, faisons connaissance avec Apache Parquet et expliquons pourquoi il est en passe de devenir un élément essentiel de votre boîte à outils de données. Il y a de fortes chances qu'il devienne votre nouvel outil préféré.

Qu'en est-il d'Apache Parquet ?

En 2013, alors que la révolution du big data battait son plein, les ingénieurs de Twitter et de Cloudera cherchaient un moyen plus efficace de stocker et de traiter les grands ensembles de données. Le résultat ? Apache Parquet, un format de fichier puissant et open-source conçu pour le stockage et la récupération efficaces des données.

Mais qu'est-ce que c'est exactement ? En termes simples, Parquet est un format de fichier open-source conçu pour le stockage et la récupération efficaces des données. C'est un peu comme un classeur très bien organisé pour vos données, où tout est soigneusement trié et facile à trouver.

Voyons maintenant les caractéristiques qui font du format Parquet un format particulièrement adapté aux données télématiques :

Stockage en colonnes. Imaginez vos données télématiques comme une grande feuille de calcul détaillée. Contrairement aux formats traditionnels basés sur les lignes, Parquet stocke les données colonne par colonne, ce qui permet une analyse rapide et ciblée de paramètres spécifiques. Cela signifie que vous pouvez facilement obtenir des informations sur, par exemple, la vitesse du véhicule ou le niveau de carburant, sans avoir à passer en revue des données sans rapport entre elles. Il est conçu pour vous fournir exactement les informations dont vous avez besoin avec un minimum de frais généraux.
Compression. Parquet utilise des algorithmes de compression sophistiqués pour réduire considérablement la taille des fichiers. Ceci est essentiel pour la télématique, où les données sont générées en permanence et à des volumes élevés. En compressant les données au niveau des colonnes, Parquet minimise les coûts de stockage et réduit l'utilisation de la bande passante lors du transfert des données, optimisant ainsi l'espace et la vitesse.
Schémas d'encodage avancés. Parquet utilise une variété de schémas d'encodage pour stocker efficacement les données. Imaginez que vous suiviez des milliers de véhicules, chacun envoyant des données toutes les quelques secondes. Vous aurez des colonnes à forte répétition (identifiants des véhicules), d'autres à faible cardinalité (codes d'état), et d'autres encore avec de petites variations (coordonnées GPS). Les schémas d'encodage de Parquet s'adaptent à chacun de ces scénarios, offrant des performances optimales en matière de stockage et d'interrogation.

En bref, Parquet vous permet de stocker et de traiter des quantités massives de données télématiques plus efficacement que les formats traditionnels. Cela signifie des requêtes plus rapides, des coûts de stockage plus faibles et la possibilité de traiter des ensembles de données plus importants sur le même matériel, autant de facteurs cruciaux pour la télématique moderne.

Parquet ou CSV : quelle est la différence ?

Nous savons ce que vous pensez. Le format CSV est le mien depuis des années. Pourquoi devrais-je changer ? C'est une bonne question ! Voyons ce qu'il en est avec une bonne vieille comparaison :

| Fonctionnalité | Parquet | CSV | ---------------------------------- | ----------------------------------------------- | ---------------------------- | Type de stockage | Colonnes | Brutes | Taille de fichier | Plus petit (grâce à la compression) | Plus grand | | Performances de requête | Plus rapide (en particulier pour les requêtes spécifiques aux colonnes) | Plus lent | Gestion des schémas | Prise en charge intégrée des schémas | Pas de prise en charge des schémas | Préservation des types de données | Tout est stocké sous forme de texte | Fractionnable pour le traitement parallèle | Oui | Non (sans travail supplémentaire) | Lisible par l'homme | Non (format binaire)

En regardant ce tableau, vous vous dites peut-être : "Wow, Parquet a l'air génial ! Pourquoi tout le monde ne l'utilise-t-il pas ?

Eh bien, la raison pour laquelle le format CSV a encore sa place est qu'il est simple, lisible par l'homme, et qu'il fonctionne bien pour les petits ensembles de données ou lorsque vous avez besoin d'inspecter rapidement les données. ( Navixy propose également le format CSV).

Mais lorsqu'il s'agit de traiter les volumes massifs de données que les systèmes IoT et télématiques modernes génèrent, c'est là que le format Parquet se démarque vraiment. C'est comme passer d'un vélo à une voiture de sport - les deux vous mènent à bon port, mais l'un d'entre eux le fait avec beaucoup plus de puissance et d'efficacité.

Ainsi, la prochaine fois que vous vous débattrez avec un fichier CSV géant et que vous verrez votre ventilateur d'ordinateur faire des heures supplémentaires, rappelez-vous qu'il existe un moyen plus rapide et plus efficace. Ce moyen, c'est Parquet.

Passons en revue quelques cas d'utilisation pour mieux comprendre comment il fonctionne pour les professionnels qui traitent des données télématiques.

Qui peut bénéficier du support Parquet chez Navixy ?

L'intégration du support Parquet dans l'API de données brutes de Navixy est utile pour différents rôles dans l'écosystème des données, tels que les développeurs de logiciels, les ingénieurs de données et les analystes de données/scientifiques. En quoi l'utilisation du format de fichier Parquet peut-elle leur être utile ?

Développeurs de logiciels - la puissance d'un traitement efficace des données

Pour les développeurs de logiciels qui travaillent avec des données télématiques et IoT, la prise en charge de Parquet ouvre de nouvelles possibilités de gestion et de traitement efficaces des données, avec une intégration native dans les outils big data et une optimisation pour le traitement des grands ensembles de données.

Intégration plus facile avec les outils et frameworks big data

Le format de fichier Parquet est pris en charge de manière native sur les principales plateformes cloud telles que AWS, GCP et Azure. Les fichiers Parquet peuvent être stockés efficacement dans des services de stockage d'objets en nuage tels que AWS S3, Google Cloud Storage et Azure Data Lake Storage. Cela permet une intégration transparente avec des services d'analyse puissants comme AWS Athena, Google BigQuery et Azure Synapse Analytics pour des requêtes et des analyses de données efficaces.

Amélioration des performances des applications lors du traitement de grands ensembles de données.

Dans le format columnar de Parquet, les données sont stockées par colonne plutôt que par ligne, ce qui vous permet de récupérer uniquement les colonnes dont vous avez besoin. Par exemple, si vous analysez la vitesse, la latitude et la longitude d'un véhicule, Parquet ne lit que ces colonnes, sans tenir compte des données non pertinentes telles que la température du moteur ou le niveau de carburant. Cela réduit les entrées/sorties sur disque, car chaque colonne est stockée dans des blocs séparés, et les métadonnées dans le pied de page du fichier aident Parquet à localiser rapidement et à charger uniquement les colonnes nécessaires. Cet accès efficace améliore considérablement les performances, en particulier pour les grands ensembles de données télématiques.

Parquet prend également en charge la fonction "pushdown" des prédicats, ce qui signifie que les opérations de filtrage peuvent être exécutées au niveau de la couche de stockage, réduisant ainsi de manière significative la quantité de données à lire et à traiter. Par exemple, dans une requête SQL comme celle-ci :

SELECT device_id, timestamp, location FROM telemetry_data WHERE date = '2023-06-01' AND speed > 60

Predicate pushdown est essentiellement un terme fantaisiste pour filtrer les données au niveau de la couche de stockage. Au lieu de charger un ensemble de données dans la mémoire et d'appliquer ensuite des filtres, la fonction predicate pushdown permet à Parquet de vérifier les conditions directement dans la couche de stockage.

Voici comment cela fonctionne :

Les fichiers Parquet contiennent des métadonnées qui comprennent des informations sur les valeurs minimales et maximales de chaque colonne pour chaque groupe de lignes.
Lorsqu'une requête avec une condition de filtrage est exécutée, Parquet vérifie d'abord ces métadonnées pour déterminer quels groupes de lignes contiennent potentiellement des données pertinentes.
Seuls les groupes de lignes susceptibles de satisfaire aux conditions de la requête sont lus à partir du disque, ce qui réduit considérablement les opérations d'entrée/sortie.

Cette méthode permet souvent de réduire le volume de données lues d'un ordre de grandeur. Par exemple, si vous interrogez des données sur des véhicules dont la vitesse est supérieure à un certain seuil, la méthode predicate pushdown permet à Parquet d'analyser uniquement les blocs pertinents contenant des données qui correspondent à ces filtres, sur la base des valeurs de vitesse minimale/maximale stockées dans les métadonnées.

Ingénieurs de données - optimisation des pipelines de données

Pour les ingénieurs de données qui utilisent Navixy, la prise en charge de Parquet signifie une rationalisation des processus ETL et une amélioration de l'efficacité des pipelines de données. Les données télématiques provenant des capteurs des véhicules peuvent être ingérées et transformées jusqu'à trois fois plus rapidement, ce qui réduit les coûts de stockage de 75 % et permet des flux de données plus fluides avec des analyses par lots améliorées sur les performances de la flotte. Par exemple, dans un cas d'utilisation du trafic de la ville de Mexico, le fichier de données était de 8 Go au format Parquet, contre 35 Go au format CSV et 57 Go au format JSON.

Rationalisation des processus ETL

L'évolution du schéma de Parquet est une fonction incroyablement utile pour gérer la nature dynamique des données IoT des véhicules. C'est comme si vous disposiez d'une base de données flexible qui s'adapte à l'évolution de vos besoins, sans les problèmes habituels de changement de schéma.

Imaginez que vous travaillez pour une société de leasing et que vous collectez les données des bus CAN d'une flotte de camions pour les opérations de maintenance - suivi du kilométrage, de l'état de l'allumage et de la température du moteur. Tout se passe bien. Puis, de nouvelles exigences commerciales apparaissent et vous devez analyser l'utilisation du véhicule en surveillant le régime et la position de la pédale d'accélérateur pour comprendre le comportement du conducteur. Avec Parquet, l'ajout de ces nouveaux points de données est un jeu d'enfant.

De plus, les fichiers Parquet sont facilement partitionnables, ce qui permet une organisation efficace des données. Dans le domaine de la télématique automobile, vous pouvez partitionner les données en fonction de la date et de l'identifiant de l'appareil, en créant une structure comme celle-ci :

/data /date=2023-06-01 /device_id=1234 0000.parquet 0001.parquet /device_id=5678 0000.parquet /date=2023-06-02 ...

Explication de la structure de cet exemple :

/data : Le répertoire racine où toutes les données sont stockées.
/date=2023-06-01 : Partitionné par date. Toutes les données du 1er juin 2023 se trouvent dans ce répertoire.
/device_id=1234 : Sous-partition par ID d'appareil. Contient les données de l'appareil portant l'ID 1234 pour le 1er juin 2023.
0000.parquet, 0001.parquet : Fichiers de données Parquet contenant des parties des données de cet appareil pour la date spécifiée.
/device_id=5678 : Données provenant d'un autre appareil portant l'ID 5678 pour la même date.
/date=2023-06-02 : Données pour le 2 juin 2023, avec une structure interne similaire.

Grâce à cette structure, il est facile d'extraire et de traiter des sous-ensembles spécifiques de données. Par exemple, si vous souhaitez analyser l'activité d'un véhicule particulier un jour donné, vous pouvez rapidement localiser le fichier Parquet exact. Cet accès ciblé permet non seulement d'accélérer le traitement des données, mais aussi de réduire les opérations d'E/S inutiles, ce qui le rend particulièrement utile pour les grands ensembles de données télématiques.

La structure de vos fichiers Parquet doit s'aligner sur les besoins spécifiques du consommateur de données. Si certaines stratégies de partitionnement peuvent optimiser les performances pour un cas d'utilisation, elles peuvent être moins performantes dans d'autres cas. C'est pourquoi il est important de bien comprendre votre cas d'utilisation lorsque vous travaillez avec Parquet, en veillant à ce que la structure du fichier soit optimisée pour une interrogation et un accès aux données efficaces, en fonction de vos besoins particuliers.

Une meilleure efficacité du pipeline de données

Lorsqu'il s'agit d'améliorer l'efficacité du pipeline de données, Parquet apporte plusieurs avantages clés. La réduction de l'utilisation du stockage et du réseau, ainsi que des performances d'écriture plus rapides, en font un format de choix pour le traitement des grands ensembles de données, en particulier pour les données télématiques, qui peuvent croître rapidement.

Le format de stockage en colonnes de Parquet est conçu pour minimiser l'espace de stockage en utilisant des algorithmes de compression tels que Snappy, Gzip et LZO. Ces algorithmes réduisent la taille de chaque colonne indépendamment, ce qui est particulièrement efficace lorsqu'il s'agit de données répétitives, telles que la vitesse du véhicule ou l'emplacement dans les données télématiques. En réduisant la taille des fichiers, Parquet permet d'économiser sur les coûts de stockage et de réduire les temps de transfert sur le réseau lors du déplacement des données entre les systèmes ou les solutions de stockage en nuage.

Un autre aspect important de Parquet est sa structure de fichier, qui permet une lecture et un traitement efficaces. Chaque fichier Parquet est marqué par des octets magiques "PAR1" au début et à la fin. Cette structure permet de travailler plus rapidement avec les fichiers existants, car elle aide les systèmes à identifier et à valider rapidement les fichiers Parquet.

Cependant, il est important de noter que les fichiers Parquet ne sont pas conçus pour l'ajout direct de nouvelles données. Au contraire, lorsqu'il s'agit de données en continu ou fréquemment mises à jour, comme dans les applications télématiques, l'approche habituelle consiste à créer de nouveaux fichiers Parquet pour les nouveaux lots de données.

Cette approche est particulièrement utile dans le domaine de la télématique, où les données circulent en continu et où de nouvelles informations - telles que la position des véhicules, les relevés des capteurs ou les mesures du comportement des conducteurs - sont fréquemment générées. Le format Parquet permet de créer efficacement de nouveaux fichiers, qui peuvent ensuite être facilement intégrés dans les flux de traitement des données.

Pour les scénarios nécessitant des mises à jour fréquentes, les technologies construites au-dessus de Parquet, telles que Apache Iceberg ou Delta Lake, offrent des fonctionnalités supplémentaires pour gérer des ensembles de données en évolution tout en conservant les avantages en termes de performances du stockage en colonnes de Parquet.

Analystes de données et scientifiques - un accès plus rapide aux informations

Pour ceux qui travaillent à l'extraction d'informations à partir de données télématiques, la prise en charge de Parquet peut accélérer considérablement les flux de travail.

Exploration et analyse plus rapides des données

Des requêtes efficaces et un accès facile aux métadonnées rationalisent le processus d'analyse, permettant aux utilisateurs d'extraire rapidement des points de données spécifiques et d'obtenir des informations sans avoir à parcourir des ensembles de données entiers. Cette efficacité ne réduit pas seulement le temps de traitement, mais ajoute également de la flexibilité aux flux de travail en permettant un filtrage, un tri et une agrégation rapides des données.

Le format en colonnes permet des agrégations et des opérations de filtrage rapides. Par exemple, en utilisant PyArrow de Python :

import pyarrow.parquet as pq table = pq.read_table('navixy_data.parquet') filtered_table = table.filter((table['speed'] > 60) & (table['fuel_level'] < 20)) print(filtered_table.to_pandas())

Les fichiers Parquet contiennent des métadonnées qui peuvent être consultées instantanément, ce qui élimine la nécessité d'analyser l'ensemble du fichier. Grâce au stockage intégré des métadonnées de Parquet, les utilisateurs peuvent consulter des résumés de données détaillés et des informations sur le schéma dès le départ, ce qui leur permet de comprendre clairement la structure et le contenu de l'ensemble de données avant de se lancer dans une analyse plus approfondie. Cela permet d'appréhender rapidement les caractéristiques des données :

fichier_parquet = pq.ParquetFile('navixy_data.parquet') print(fichier_parquet.metadata) print(fichier_parquet.schema)

Compatibilité améliorée avec les outils de science des données les plus répandus

Le format Parquet s'intègre parfaitement dans l'écosystème Python et est hautement évolutif, ce qui le rend idéal pour les flux de travail de science des données en Python et R.

Des bibliothèques telles que Pandas, PyArrow et Dask offrent un support solide pour les fichiers Parquet, permettant une manipulation et une analyse efficaces des données :

import pandas as pd df = pd.read_parquet('navixy_data.parquet') print(df.describe())

Dans R, le package arrow fournit une intégration Parquet fluide, permettant aux utilisateurs de travailler avec des fichiers Parquet aussi facilement qu'ils le feraient avec des cadres de données R natifs :

library(arrow) df <- read_parquet("navixy_data.parquet") summary(df)

Lorsque les ensembles de données dépassent les limites de la mémoire, Dask en Python permet un traitement extensible et hors du cœur pour les fichiers Parquet, ce qui vous permet de travailler efficacement avec de grands ensembles de données :

import dask.dataframe as dd ddf = dd.read_parquet('navixy_data.parquet') result = ddf.groupby('device_id')['speed'].mean().compute()

La popularité de Parquet et la prochaine étape avec Delta Lake

Des recherches récentes mettent en évidence la domination croissante de Parquet dans le domaine des données volumineuses. Une étude de Dong et al. (2023) a révélé que l 'utilisation de Parquet a augmenté de 45 % dans les industries à forte intensité de données en trois ans, dépassant des formats comme Avro et ORC. De même, Sharma et Gupta (2022) ont rapporté que 68% des ingénieurs de données préfèrent Parquet pour ses performances de requête et son efficacité de stockage. Chen et al. (2024) ont également montré que 72 % des nouvelles implémentations de lacs de données utilisent Parquet, grâce à sa compression et à son intégration transparente avec les outils big data.

Collectivement, ces résultats soulignent la popularité croissante de Parquet, en particulier dans les secteurs gérant des ensembles de données complexes et volumineux tels que la télématique et l'IdO.

Pour les entreprises à la recherche d'une infrastructure de données encore plus robuste, Delta Lake s'appuie sur les fondations de Parquet avec des fonctionnalités telles que la cohérence transactionnelle, l'évolution des schémas et le versionnage. Souvent appelé Parquet sous stéroïdes, Delta Lake permet une gestion fiable des données et des analyses avancées, ce qui en fait la solution idéale pour les ensembles de données complexes et à grande vitesse.

Passons maintenant de la théorie à la pratique et voyons comment travailler avec le format de fichier Parquet dans l'API de données brutes de Navixy.

Comment récupérer des données au format Parquet en utilisant l'API de données brutes de Navixy ?

Voyons maintenant comment vous pouvez commencer à tirer parti du format Parquet avec l'API Navixy pour gérer les données brutes, parallèlement à l'option CSV familière, en utilisant le nouveau paramètre format dans la méthode raw_data/read.

Nouveau paramètre : format

Pour prendre en charge l'option Parquet, nous avons ajouté un nouveau paramètre au point de terminaison /raw_data/read:

format : Spécifie le format de sortie. Il accepte soit "csv" (par défaut), soit "parquet".

Appel d'API mis à jour

Voici comment utiliser l'API mise à jour pour récupérer des données au format Parquet à l'aide d'un script bash Linux :

#!/bin/bash curl -X 'POST' \ 'https://api.eu.navixy.com/dwh/v1/tracker/raw_data/read' \ -H 'accept : application/octet-stream' \ 'Content-Type : application/json' \ -d '{ "hash" : "feed0000000000000000cafe", "tracker_id" : "3036057", "from" : "2024-09-10T02:00:00Z", "to" : "2024-09-10T06:00:00Z", "columns" : ["lat", "lng", "speed", "inputs.can_fuel_litres" ], "format" : "parquet" }' \ --output navixy_data.parquet

Jetez un coup d'œil à la vidéo ci-dessous pour voir comment procéder, étape par étape.

Principaux changements :

Le paramètre "format" : "parquet" est ajouté au corps de la requête.

L'en-tête accept est défini à application/octet-stream pour gérer les données Parquet binaires.

Traitement de la réponse

Lorsque vous demandez le format Parquet, vous recevez un flux de fichiers binaires plutôt qu'une chaîne CSV. Voici un moyen rapide d'enregistrer ces données dans un fichier à l'aide de Python :

import requests url = "https://api.eu.navixy.com/dwh/v1/tracker/raw_data/read" headers = { "accept" : "application/octet-stream", "Content-Type" : "application/json" } data = { "hash" : "feed0000000000000000cafe", "tracker_id" : "3036057", "from" : "2024-09-10T02:00:00Z", "to" : "2024-09-10T06:00:00Z", "columns" : [ "lat", "lng", "speed", "inputs.can_fuel_litres" ], "format" : "parquet" } response = requests.post(url, headers=headers, json=data) if response.status_code == 200 : with open("navixy_data.parquet", "wb") as f : f.write(response.content) print("Parquet file saved successfully !") else : print(f "Error : {response.status_code}, {response.text}")

Vous pouvez regarder la vidéo ci-dessous pour mieux comprendre le processus.

Lecture du fichier Parquet

Une fois que vous avez enregistré le fichier Parquet, vous pouvez le lire avec PyArrow ou Pandas pour explorer et analyser vos données. Installez l'utilitaire parquet-cli (qui comprend les bibliothèques PyArrow et Pandas)

pip install parquet-cli

Effectuez la lecture :

import pyarrow.parquet as pq # Lire le fichier Parquet table = pq.read_table("navixy_data.parquet") # Convertir en DataFrame Pandas si nécessaire df = table.to_pandas() print(df.head())

Il serait également utile de compléter cet exemple en lisant le fichier parquet à l'aide de l'utilitaire Parquet CLI.

Ouvrez le fichier précédemment téléchargé en utilisant le jeu de commandes suivant :

parq navixy_data.parquet parq navixy_data.parquet --schema parq navixy_data.parquet --head 5 parq navixy_data.parquet --tail 5

Compatibilité ascendante

Pas d'inquiétude si vous n'êtes pas encore prêt à passer à Parquet. L'API utilise par défaut le format CSV si aucun format n'est spécifié, de sorte que les intégrations existantes fonctionneront de manière transparente sans aucune modification.

Meilleures pratiques

Si vous pensez devoir opter pour le format Parquet, vous pouvez consulter les meilleures pratiques suivantes.

Sélectionnez les colonnes de manière réfléchie : avec Parquet, il est encore plus efficace de ne récupérer que les colonnes dont vous avez besoin.
Optimisez les plages de temps : diviser les requêtes en plus petites tranches de temps peut faciliter le traitement parallèle.
Utilisez les métadonnées Parquet : des outils comme PyArrow vous permettent d'inspecter les schémas et les statistiques des fichiers Parquet sans charger l'intégralité du fichier, ce qui permet de gagner du temps.

Prêt à essayer Parquet ? Commencez dès aujourd'hui

En résumé, l'ajout du format Apache Parquet à l'API de données brutes de Navixy change la donne pour tous ceux qui travaillent avec des données télématiques. Il permet d'économiser de l'espace, d'accélérer le traitement des données et de faciliter la gestion de grands volumes de données. Pour les professionnels des données télématiques, il peut en résulter des informations plus rapides, une manipulation plus aisée des données et un moyen plus efficace de travailler avec des ensembles de données complexes et de tirer le meilleur parti des données télématiques - sans les maux de tête.

Si cela vous intrigue et que vous n'utilisez pas encore Navixy Raw Data API, c'est le moment de voir ce que vous manquez. Avec notre dernier support Parquet, vous pouvez rationaliser le traitement de vos données, réduire les coûts de stockage et plonger dans les informations télématiques comme jamais auparavant.

Vous voulez en savoir plus ?

Que vous soyez développeur, ingénieur de données ou analyste, Navixy est là pour faire travailler le big data pour vous. Contactez notre équipe pour en savoir plus sur la façon de rendre les données IoT plus accessibles, exploitables et efficaces.

Format Parquet pour la télématique : Comment rationaliser le traitement des données des véhicules avec l'API Navixy