Qu'est-ce que le Parquet?
Apache Parquet est un format de fichier open-source souvent utilisé pour les données volumineuses dans les clusters Hadoop. Parquet stocke les données à l'aide d'un format de données plat, compressé et stocké stockage en colonnes . Apache Spark fournit des API de haut niveau aux développeurs, notamment support Java, Scala, Python et R. Parquet est bien adapté au stockage efficace de structures de données imbriquées.
Caractéristiques du Parquet
Comprendre les caractéristiques de Parquet permet de comprendre pourquoi il est un choix si intéressant pour les professionnels des données :
- stockage en colonnes: Parquet stocke les données en colonnes, ce qui est idéal pour les requêtes analytiques. Avec le stockage en colonnes, chaque colonne est stockée indépendamment, ce qui permet un accès beaucoup plus rapide à des points de données spécifiques par rapport aux formats basés sur les lignes.
- Compression efficace : L'une des caractéristiques les plus remarquables de Parquet est sa capacité à compresser efficacement les données. stockage en colonnes permet aux types de données similaires d'être stockés ensemble, ce qui rend les algorithmes de compression tels que Snappy, Gzip et LZO très efficaces. Cela permet de réduire la taille globale des fichiers et de réaliser des économies sur les coûts de stockage.
- Support schéma : Les fichiers Parquet comprennent un Embarqué métadonnées qui décrit la structure des données, ce qui simplifie le traitement et assure la cohérence entre les différents systèmes. Le schéma est stocké avec les données, ce qui permet aux outils de traitement des données de les comprendre et de les interpréter correctement.
- Open-Source et multiplateforme : Parquet est un format open-source et sa flexibilité lui permet de fonctionner sur différentes plateformes données et cadres de traitement. Largement adopté par la communauté open-source, il est pris en charge par divers outils et plateformes big data, ce qui le rend très polyvalent.
Avantages du Parquet
Les avantages de l'utilisation de Parquet vont au-delà de ses caractéristiques techniques, offrant une réelle valeur ajoutée aux organisations traitant de grands volumes de données :
- Amélioration des performances : Les fichiers Parquet support fonction predicate pushdown, qui permet aux requêtes d'ignorer les données inutiles et de ne parcourir que les sections pertinentes du fichier. Cela se traduit par des requête plus rapides que dans d'autres formats comme le CSV, en particulier lorsqu'il s'agit de requêtes analytiques complexes.
- Réduction des coûts de stockage : Les avantages de Parquet en matière de compression sont considérables. Les données étant stockées plus efficacement, elles occupent moins d'espace, ce qui se traduit par une réduction des coûts de stockage. Ceci est particulièrement important dans les environnements de big data où le volume de données peut rapidement devenir énorme.
- Optimisé pour les charges de travail analytiques : Parquet a été spécialement conçu pour les charges de travail analytiques. Dans les environnements où il est nécessaire d'exécuter des requêtes fréquentes et des traitements de données à grande échelle, Parquet s'impose comme le format de choix. Il permet aux organisations de traiter les données plus rapidement et plus efficacement.
- Compatibilité avec les frameworks de traitement de données : Parquet s'intègre de manière transparente aux frameworks de traitement de données les plus répandus, comme Apache Spark, Apache Hive et Apache Flink. Cela en fait un choix naturel pour les organisations qui utilisent déjà ces outils.
Avantages du stockage des données en colonnes
Le stockage des données dans un format en colonnes tel que Parquet présente des avantages significatifs par rapport aux formats traditionnels basés sur des lignes, tels que CSV :
- requête efficace Performance : L'un des principaux avantages des formats en colonnes est que seules les colonnes pertinentes sont lues lors des requêtes, ce qui accélère considérablement la récupération des données. En revanche, les formats basés sur des lignes nécessitent la lecture de l'ensemble du fichier, même si seule une petite partie des données est nécessaire.
- Meilleurs taux de compression : Étant donné que les données dans un format en colonnes sont souvent du même type et de la même structure, elles peuvent être compressées plus efficacement. Cela permet de réduire l'empreinte globale de stockage des données et de minimiser le nombre de ressources nécessaires au transfert et au stockage des données.
- Flexibilité avec les structures de données complexes : Parquet permet de stocker des structures de données complexes imbriquées, telles que des tableaux, des cartes et des structures. Cette capacité le rend particulièrement utile pour le stockage de données dans les systèmes modernes et distribués, où les relations entre les différents points de données peuvent être complexes.
Parquet vs. CSV : Principales différences
Lorsque l'on compare Parquet au format CSV plus traditionnel, plusieurs différences importantes apparaissent :
- Efficacité du stockage : Les fichiers Parquet sont beaucoup plus efficaces en termes d'espace que les fichiers CSV, principalement en raison de leur structure en colonnes et des meilleures techniques de compression. Un fichier CSV peut être beaucoup plus volumineux, en particulier pour les grands ensembles de données.
- requête Performance : Le format en colonnes de Parquetpermet des requêtes plus rapides et plus ciblées, alors que les fichiers CSV nécessitent le chargement de l'ensemble du jeu de données en mémoire. Cela peut ralentir considérablement les performances des requête , en particulier lorsqu'il s'agit de grands ensembles de données.
- évolutif : Parquet est beaucoup plus évolutif que CSV. Lorsque votre jeu de données atteint des téraoctets, voire des pétaoctets, Parquet gère la taille et la complexité bien mieux que CSV.
- Intégrité des données : Avec Parquet, les métadonnées et le schéma sont stockés avec les données, ce qui permet de maintenir l'intégrité et la structure du jeu de données. En revanche, les fichiers CSV ne contiennent pas d'informations sur les schémas, ce qui peut entraîner des incohérences et des erreurs lorsque les données sont transférées entre différents systèmes.
Stockage
Un fichier Parquet se compose de groupes de lignes. Les groupes de lignes contiennent un sous-ensemble de données stockées sous forme de pages. Les pages sont regroupées en morceaux de colonnes. Les morceaux de colonnes contiennent des informations métadonnées qui comprennent le nombre de valeurs définies, leur taille et des statistiques telles que le nombre de valeurs nulles et min/max.
Types de données Parquet
Parquet prend en charge plusieurs types de données de 320 bits. Il s'agit notamment des types suivants :
- BOOLEAN : booléen à 1 bit
- INT32 : Ints signés de 32 bits
- INT64 : Ints signés de 64 bits
- INT96 : Ints signés de 96 bits
- FLOAT : valeurs à virgule flottante IEEE 32 bits
- DOUBLE : valeurs à virgule flottante IEEE 64 bits
- BYTE_ARRAY : tableaux d'octets de longueur arbitraire
- FIXED_LEN_BYTE_ARRAY : tableaux d'octets de longueur fixe
Compression dans le Parquet
Parquet stocke de grands ensembles de données, la compression est donc une caractéristique importante de ce format de fichier. Différents algorithmes de compression peuvent être appliqués par colonne. Les codecs de compression suivants sont fournis avec la distribution de base :
- GZIP : convient au stockage statique à long terme tel que l'archivage de données. GZIP permet une plus grande compression que Snappy mais consomme plus de ressources du processeur .
- Snappy : est un bon choix pour les données chaudes auxquelles on accède souvent. Les vitesses de décompression de Snappy sont inférieures à celles de GZIP. Snappy est fractionnable (contrairement à GZIP).
- LZO : est un bon choix si votre application nécessite des vitesses de décompression élevées.
Hadoop
Hadoop est une plateforme open-source qui s'adapte horizontalement aux charges de travail liées aux données volumineuses (big data). Parquet a été développé principalement pour les environnements Hadoop. De nombreuses organisations ont créé des clusters Hadoop à l'apogée du mouvement big data. Malheureusement, les compétences en matière de réglage Hadoop sont devenues rares, et les organisations déplacent donc leurs données Parquet vers des architectures plus modernes. Les systèmes Hadoop tels que Pig, Hive et Spark utilisent Parquet. Spark fournit la meilleure API pour accéder aux données Parquet . Les systèmes modernes d'entreposage de données tels que la plateforme de données Actian utilisent un connecteur Spark pour accéder aux données Parquet où qu'elles se trouvent, sur site ou dans le nuage.
plateforme de données Actian
A l'aide d'un connecteur Spark, la plateforme de données Actian peut accéder à Parquet en tant qu'objet externe. Les prédicats peuvent être poussés vers le bas vers Parquet pour améliorer les vitesses d'accès. Les données Parquet externes sont faciles à charger car les requêtes peuvent être enveloppées dans du SQL. Le chargement des données parquet dans des tables offre l'accès le plus rapide aux données grâce au traitement vectoriel qui charge les données en colonnes dans le cache du processeur sur un serveur ou un cluster afin de maximiser le traitement parallèle des requêtes. Les benchmarks ont montré que la plateforme de données Actian peut évoluer d'un ordre de grandeur supérieur à Hive.
Dans les exemples ci-dessous, une source de données externe Parquet est mappée en tant que table externe avant de charger ses données dans une table interne pour un accès plus rapide à l'application.
Chargement de données Parquet à partir de Google Cloud Storage :
DROP TABLE IF EXISTS pemdata_gs ;
CREATE EXTERNAL TABLE pemdata_gs (
période VARCHAR(20),
flow1 VARCHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) en utilisant spark
AVEC
reference='gs://avpemdata/part*parquet',
format='parquet' ;
DROP TABLE IF EXISTS pemdata ;
CREATE TABLE pemdata (
période TIMESTAMP,
flow1 VARCHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) ;
Chargement de données Parquet à partir d'Azure Blob Storage :
DROP TABLE IF EXISTS pemdata_adl ;
CREATE EXTERNAL TABLE pemdata_adl (
période VARCHAR(20),
flow1 VARCHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) en utilisant spark
AVEC
reference='abfs://parquetdata@mydata.dfs.core.windows.net//part*parquet',
format='parquet' ;
DROP TABLE IF EXISTS pemdata ;
CREATE TABLE pemdata (
période TIMESTAMP,
flow1 VACHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) ;
INSERT INTO pemdata SELECT * FROM pemdata_adl ;
Chargement de données Parquet à partir du stockage AWS S3 :
DROP TABLE IF EXISTS pemdata_s3 ;
CREATE EXTERNAL TABLE pemdata_s3 (
période VARCHAR(20),
flow1 VARCHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) en utilisant spark
AVEC
reference='s3a://avpemdata/part*parquet',
format='parquet' ;
DROP TABLE IF EXISTS pemdata ;
CREATE TABLE pemdata (
période TIMESTAMP,
flow1 VARCHAR(20),
flow2 VARCHAR(20),
occupation1 VARCHAR(20),
speed1 VARCHAR(20)
) ;
INSERT INTO pemdata SELECT * FROM pemdata_s3 ;
