Visão geral do acesso a arquivos - Data Lake Formation: Central de Documentação do Alibaba Cloud

O PVFS (Paimon Virtual Storage) permite acessar tabelas Paimon em um catálogo do Data Lake Formation (DLF) por caminhos de arquivo padrão, sem iniciar um mecanismo de computação como Flink ou Spark.

O PVFS mapeia os metadados e a estrutura de armazenamento de uma tabela Paimon em um caminho virtual unificado. Use esse caminho para ler diretamente o conteúdo subjacente da tabela — snapshots, arquivos de dados e metadados — com o Java SDK ou o Python SDK. O formato do caminho é idêntico em ambos os SDKs e em todos os frameworks de computação compatíveis.

pvfs://<catalog_name>/<database_name>/<table_name>/...

Para mais informações sobre o design do PVFS, consulte Paimon Virtual Storage.

O PVFS permite que desenvolvedores e engenheiros de dados explorem, testem e gerenciem tabelas Paimon em ambientes locais ou automatizados por scripts, aumentando a eficiência no desenvolvimento e na operação e manutenção de data lakes.

Suporte a SDK

Java SDK: Implementa a interface do Hadoop Distributed File System (HDFS) e integra-se ao ecossistema Hadoop, incluindo Hive, Spark e Presto.
Python SDK: Desenvolvido com base no Filesystem Spec (fsspec), é compatível com ferramentas de dados Python como Dask, Pandas e PyArrow.

Estrutura do caminho

Todos os caminhos do PVFS seguem um namespace de três níveis:

pvfs://<catalog_name>/<database_name>/<table_name>/[path]

Segmento	Descrição
`catalog_name`	Nome do catálogo DLF
`database_name`	Banco de dados no catálogo
`table_name`	Tabela Paimon a acessar
`path`	Opcional. Caminho relativo para um arquivo ou diretório específico na tabela

Comportamento de listagem

Ao listar um caminho PVFS, a resposta reflete a hierarquia do namespace virtual:

pvfs://<catalog_name>/ — retorna todos os bancos de dados do catálogo como caminhos virtuais
pvfs://<catalog_name>/<database_name>/ — retorna todas as tabelas do banco de dados como caminhos virtuais
pvfs://<catalog_name>/<database_name>/<table_name>/ — retorna os arquivos e diretórios reais da tabela

Todos os caminhos listados são virtuais. As operações de leitura e gravação resolvem automaticamente o caminho virtual para o local de armazenamento real da tabela.

Java SDK

O Java SDK implementa a interface HDFS, tornando o PVFS acessível em qualquer framework compatível com Hadoop.

Pré-requisitos

Antes de começar, verifique se você tem:

Java 8 ou superior
Um catálogo DLF com pelo menos uma tabela Paimon
Um token de acesso DLF válido

Configure com a API Hadoop FileSystem

Defina as seguintes propriedades no objeto Configuration ou no arquivo core-site.xml:

Propriedade	Valor	Descrição
`fs.pvfs.impl`	`org.apache.paimon.vfs.hadoop.PaimonVirtualFileSystem`	Classe de implementação do FileSystem PVFS
`fs.pvfs.uri`	URL do endpoint DLF	Endpoint do service DLF

Exemplo: leitura de arquivo com a API Hadoop FileSystem

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

Configuration conf = new Configuration();
conf.set("fs.pvfs.impl", "org.apache.paimon.vfs.hadoop.PaimonVirtualFileSystem");
// Replace <dlf-endpoint> with the actual DLF service endpoint
conf.set("fs.pvfs.uri", "<dlf-endpoint>");

Path path = new Path("pvfs://<catalog_name>/<database_name>/<table_name>/");
FileSystem fs = path.getFileSystem(conf);
// List files in the table
fs.listStatus(path);

**Exemplo: configuração no core-site.xml para acesso em todo o cluster**

<configuration>
  <property>
    <name>fs.pvfs.impl</name>
    <value>org.apache.paimon.vfs.hadoop.PaimonVirtualFileSystem</value>
  </property>
  <property>
    <name>fs.pvfs.uri</name>
    <!-- Replace with the actual DLF service endpoint -->
    <value><dlf-endpoint></value>
  </property>
</configuration>

Após adicionar essas propriedades, frameworks como Hive, Spark e Presto acessam caminhos PVFS sem configuração adicional.

Exemplo: consulta a uma tabela com Spark SQL

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder()
  .config("spark.hadoop.fs.pvfs.impl",
          "org.apache.paimon.vfs.hadoop.PaimonVirtualFileSystem")
  // Replace <dlf-endpoint> with the actual DLF service endpoint
  .config("spark.hadoop.fs.pvfs.uri", "<dlf-endpoint>")
  .getOrCreate()

spark.sql("""
  CREATE TEMPORARY VIEW my_table
  USING parquet
  OPTIONS (path 'pvfs://<catalog_name>/<database_name>/<table_name>/')
""")
spark.sql("SELECT * FROM my_table LIMIT 10").show()

Python SDK

O Python SDK implementa a interface fsspec, permitindo usar o PVFS com qualquer biblioteca Python compatível com fsspec.

Pré-requisitos

Antes de começar, verifique se você tem:

Python 3.7 ou superior
pypaimon instalado
Um catálogo DLF com pelo menos uma tabela Paimon
Um token de acesso DLF válido

Inicialize o sistema de arquivos

Forneça as seguintes opções ao criar uma instância de PaimonVirtualFileSystem:

Parâmetro	Tipo	Obrigatório	Descrição
`uri`	str	Sim	URL do endpoint do service DLF
`token.provider`	str	Sim	Tipo de provedor de autenticação
`token`	str	Sim	Token de acesso DLF

import pypaimon

options = {
    "uri": "<dlf-endpoint>",          # Replace with the DLF service endpoint
    "token.provider": "dlf",
    "token": "<your-dlf-token>",      # Replace with a valid DLF access token
}
fs = pypaimon.PaimonVirtualFileSystem(options)

Liste e explore tabelas

# List all tables in a database
fs.ls("pvfs://<catalog_name>/<database_name>/")

# List files in a specific table
fs.ls("pvfs://<catalog_name>/<database_name>/<table_name>/")

Leitura com PyArrow

import pypaimon
import pyarrow.parquet as pq

fs = pypaimon.PaimonVirtualFileSystem(options)

# Read a Parquet file from a Paimon table
dataset = pq.ParquetDataset(
    "pvfs://<catalog_name>/<database_name>/<table_name>/",
    filesystem=fs
)
table = dataset.read()
df = table.to_pandas()
print(df.head())

Leitura com Pandas

import pypaimon
import pandas as pd

fs = pypaimon.PaimonVirtualFileSystem(options)

# Read a CSV file from a Paimon table
with fs.open("pvfs://<catalog_name>/<database_name>/<table_name>/data.csv") as f:
    df = pd.read_csv(f)
print(df.head())

Controle de acesso

O PVFS aplica as políticas unificadas de controle de acesso do DLF. O gerenciamento de permissões ocorre no nível da tabela. Os usuários precisam ter as permissões adequadas de leitura ou gravação em uma tabela DLF para acessá-la por um caminho PVFS. Para mais informações, consulte Configure permissions.