Finatext Tech Blog
🦀

Rust + PyO3で作ったPythonパッケージをSnowflake UDFで動かす

に公開
Snowflake関連記事の記事です

この記事は、ナウキャスト Advent Calendar 2025 の20日目の記事です。

はじめに

こんにちは!株式会社ナウキャストでデータエンジニアをしている福井です。

本記事では、RustコードをPyO3でPythonパッケージ化し、SnowflakeのPython UDF内で動作させる取り組みについて紹介します。

中盤でも紹介する通り、本記事で扱うコード一式は以下のGitHubリポジトリにも置いてあります
https://github.com/masamerc/pyo3-sf-demo-greeter

結論から言うと、Rustコードの統合自体は成功しました。ただし、想定していなかった制約や、ドキュメントに明記されていない挙動にもいくつかぶつかり、試行錯誤の末に2つの有効なアプローチを見つけることができました:

  1. Snowflake Stageへの直接アップロード(ZIP形式)
  2. PyPI経由での配布(Wheel形式)

本記事では、PyO3を使ったRust-Pythonバインディングの基礎情報の整理から、Snowflake特有の制約、そして実装の試行錯誤のプロセスまで、できるだけ正直に共有していきます。成功も失敗も含めて、同じことを試そうとしている方の参考になれば幸いです。

また、今回のような探索的な取り組みを安心して行えたのは、弊社でSnowflakeのサンドボックス環境が整備されていたおかげです。本番環境に影響を与えることなく、自由に実験できる環境の重要性を改めて実感しました。

なお、「実はこうしたら簡単にできる」「最近のSnowflakeのアップデートでこれができるようになった」といった情報をお持ちの方がいらっしゃいましたら、ぜひコメント欄で教えてください!日々進化がある領域ですので、情報交換もできると嬉しいです!

きっかけ

Sansan株式会社のブログからのインスピレーション

この取り組みのきっかけは、Sansan株式会社のテックブログ「なぜ私たちは住所正規化エンジンをRustで"再発明"したのか? - FFIによる多言語高速化と開発者体験の裏側」という記事でした。
BigQueryの外部UDFとしてRustコードを活用し、パフォーマンスクリティカルな住所正規化処理を大幅に高速化したという内容です。
業務において、我々も文字列正規化の処理などをSnowflakeにPython UDFで実装したりすることがあるため、Snowflakeの場合はどのようにアプローチにするかを考えるようになりました。

なぜSnowflakeでRustを使いたいのか

現時点で弊社のプロダクトにおいて、すぐにRustが必要なケースがあるわけではありません。一方で、名寄せ処理や独自のビジネスロジックをSnowflake上のUDFとして実装したいというニーズは最近増えています。

イベント登壇にて少しこの辺りは話したこともあります:
https://speakerdeck.com/masafukui/zeng-esok-kerudetatoxiang-kihe-u-shi-zu-mitositenoming-ji-setoji-pan

将来的にパフォーマンスクリティカルな処理が必要になった時、「Rustという選択肢がある」ことを知っているかどうか、技術的な引き出しを作っておくことは重要だと考えました。また次章で触れるように、SnowflakeがネイティブにPython UDFをサポートしているという特性が、シンプルにRustを統合できる可能性を開いてくれました。

個人的な話もすると、自分が趣味でRustを触っているので、「仕事でもRustが使えるかもしれない」という可能性にワクワクしたというのが正直なところではあります(笑)。

基本アプローチ・実装方針

Snowflakeで外部言語を使う選択肢

Snowflakeで外部言語(今回の場合Rust)を使おうと思った時、いくつかのアプローチが考えられます。

1: External Functions

  • AWS Lambda、Azure Functions、GCP Cloud Functionsなどを呼び出す
  • ネットワーク経由の呼び出しが必要
  • レイテンシーとコストのオーバーヘッド

2: Snowpark Container Services

  • コンテナベースのカスタムコード実行
  • より柔軟だが、Dockerイメージの準備、YAML仕様ファイルの作成、専用ロール設定などセットアップが複雑

3: Python UDFにFFI(Foreign Function Interface)でネイティブ統合

  • SnowflakeはPython UDFをネイティブサポートしている
  • インプロセス実行でネットワークレイテンシーゼロ
  • PyO3を使えばPythonから呼び出せるRustコードもUDFとして登録できる(と期待)

選択肢1や2が王道かもしれませんがもし選択肢3も簡単に実現できればかなり魅力的だと感じました:

  • 追加インフラが不要で運用がシンプル
  • 既存のSnowflake環境だけで完結
  • ネットワークレイテンシーがゼロ

業務でもSnowflakeでUDFを作成することが多々あるのですが、選択肢3のように追加インフラのセットアップなしでRustなどを選択肢として持てるとすると、パフォーマンスが必要な場面での実装の幅がかなり広がります。

というわけで、本記事では「Python UDF経由でRustを動かす」という選択肢3がどの程度簡単に実現可能なのか、探索してみることにします。

PyO3を使ったRustコードの実装アプローチ

今回はPyO3というライブラリを使ってRustでパッケージを開発し、そのパッケージをPython UDFから呼び出すというアプローチを取ります。実装に入る前に、PyO3やFFI(Foreign Function Interface)といった周辺知識を整理してみます。

FFI(Foreign Function Interface)

FFI(Foreign Function Interface)は、異なるプログラミング言語間で関数を呼び出すための仕組みです。例えば今回のようにPythonからRustで書かれた関数を呼び出す、といったことを可能にする立役者です。

PythonからRustの関数を呼ぶ際は以下のような流れで動作します:

  • Rustコードをコンパイルしてshared objectファイル(.soファイル)を生成
  • ABI(Application Binary Interface) 「関数をどう呼び出すか」のlow-levelな約束事に従って通信
    • 引数の渡し方、戻り値の受け取り方、メモリレイアウトなどが定義されている
    • 言語に依存しない共通のインターフェース
  • Pythonインタプリタが.soファイルをロードして関数を呼び出す

調べてみると実際にRustをFFI経由で使っているPythonライブラリには以下のようなものがありました:

  • Polars - Rust製の高速データフレームライブラリ
  • pyca/cryptography - Rust製の暗号化ライブラリ
  • tiktoken - OpenAIのトークナイザー(Rust実装)

これらのライブラリは内部でRustを使っていますが、Pythonから使う際にはpip install polarsしてimport polarsするだけで、あまりRustで書かれていることやFFIの存在を意識する必要はありません。

PyO3とmaturin

次に、実践的にRustコードをPythonから簡単に使えるようにするための必要なコンポーネント・ツールについて説明します。ここで登場するのがPyO3とmaturinです。

PyO3

https://github.com/PyO3/pyo3
PyO3は、Rust-Pythonバインディングを簡単に作成できるライブラリです。FFIの複雑な部分を抽象化し、型安全なインターフェースを提供してくれます。

詳しい紹介はこちらの記事が参考になります:PyO3入門

maturin

https://www.maturin.rs/
maturinは、PyO3プロジェクトをビルドしてPythonパッケージ(Wheel)を作成するツールです。pip install可能な形式に自動でパッケージングしてくれるだけでなく、PyPIへのアップロードも簡単に行えます。

実際に、先ほど紹介したライブラリもmaturinを使っています:

Polars:
https://github.com/pola-rs/polars/blob/ac0b75194fce684a7e88153e477c34c62478925d/Makefile#L100-L104

pyca/cryptography:
https://github.com/pyca/cryptography/blob/06859bf60a0a1ab26c8d03f318b51aaf32e998a8/pyproject.toml#L15

PyO3でRust関数をPython用にラップし、maturinでパッケージ化することで、polarsのようなPythonから普通に使えるRust製ライブラリが作れます。今回のUDF用のライブラリもこのPyO3 + maturinのコンビで用意をしていきます。

SnowflakeのPython UDFで自作ライブラリを使用

SnowflakeのPython UDFで自作のPythonパッケージを使用する方法はいくつかあります。公式ドキュメントによると、主に以下の選択肢があります:

A. Snowflake Stageに直接アップロード

ローカルで用意したパッケージをSnowflake Stageにアップロードし、UDFから直接参照する方法です(公式ドキュメントの該当箇所)。

CREATE FUNCTION my_function(...)
RETURNS ...
LANGUAGE PYTHON
IMPORTS = ('@my_stage/my_package.zip')
...

本命のアプローチとして、まずこの方法を試してみることにします。追加のインフラ不要で、ビルドしたパッケージをそのまま使えるシンプルさが魅力です。

B. PyPI経由での配布

パッケージをPyPIに公開し、UDFから通常のPythonパッケージとして参照する方法です。
ARTIFACT_REPOSITORY機能のリリースにより可能になりました。

CREATE FUNCTION my_function(...)
RETURNS ...
LANGUAGE PYTHON
ARTIFACT_REPOSITORY = snowflake.snowpark.pypi_shared_repository
PACKAGES = ('my-package==1.0.0')
...

Stageへの直接アップロードがうまくいかない場合の次善策として考えます。

C. Anaconda channel経由 -> 現実的ではない

Snowflake Anaconda channelに登録されているパッケージを使用する方法です。ただし、自作パッケージをAnaconda channelに登録するのは現実的ではないため、今回は選択肢から除外します。

Hands-on・検証

こちらが今回実際にやろうとしていることのOverviewで、上記のA・Bのケースで実際に動作させるまでの手順です:

  • Rust製Pythonライブラリの準備
  • Snowflake Stage / PyPIへのアップロード
  • 実行と検証

また本記事で紹介するコードはこちらのGitHubリポジトリにも置いてあります
https://github.com/masamerc/pyo3-sf-demo-greeter

Rust製Pythonライブラリの準備

今回はmaturinのプロジェクト管理もサポートしているuvを利用します。

https://docs.astral.sh/uv/

まずmaturinプロジェクトを作成します。project名は一旦pyo3-sf-demo-greeterとします:

uv init --build-backend maturin pyo3-sf-demo-greeter

以下のようなテンプレートファイルが生成されます:

$ tree .
.
└── pyo3-sf-demo-greeter
    ├── Cargo.toml
    ├── pyproject.toml
    ├── README.md
    └── src
        ├── lib.rs
        └── pyo3_sf_demo_greeter
            ├── __init__.py
            └── _core.pyi

Rustコードの実装

今回はシステム情報を取得するsysinfo crateを使い、Rustから呼び出されたことが分かるシンプルな関数を実装します。

cargo add sysinfoを実行し依存パッケージを追加し、lib.rsに以下を実装します。
Rust側はこれだけでOKです。

lib.rs
use pyo3::prelude::*;
use sysinfo::System;

/// Formats a greeting message with system information
#[pyfunction]
fn greet(name: &str) -> PyResult {
    let mut sys = System::new_all();
    sys.refresh_all();
    
    let os_name = System::name().unwrap_or_else(|| "Unknown".to_string());
    let os_version = System::os_version().unwrap_or_else(|| "Unknown".to_string());
    let hostname = System::host_name().unwrap_or_else(|| "Unknown".to_string());
    
    let greeting = format!(
        "Hello, {}! 🦀\n\
        Running on: {} {} ({})",
        name, os_name, os_version, hostname
    );
    
    Ok(greeting)
}

#[pymodule]
fn _core(m: &Bound) -> PyResult {
    m.add_function(wrap_pyfunction!(greet, m)?)?;
    Ok(())
}

Python側のインターフェース

Python側では、Rustでコンパイルされた_coreモジュールをインポートするだけの__init__.pyをまず用意します。

__init__.py
from ._core import greet

__all__ = ["greet"]

_core.pyiで型スタブを定義して型ヒントなどがIDE等で表示されるようにします。

_core.pyi
from __future__ import annotations

def greet(name: str) -> str: ...

念の為py.typedファイルも配置してこのパッケージが型情報を提供していることを宣言しておきます。

py.typed

Wheelのビルド

次に実際にビルドをしてSnowflakeで使用するためのWheelを作成します。ここで、前の章にて紹介したmaturinを使っています。make build-allをすることで、各Wheelがdist/以下に出来上がってきます。

Snowflake上のWarehouse / workerは主にLinux環境で動作するため、x86_64(Intel/AMD)とaarch64(ARM)の両方をクロスコンパイル・ビルドしておくことで、Snowflakeの異なるWarehouse typeに対応できるのではないかと思いました。
ここではdockerを用いていますが、実運用ではCICDパイプラインでクロスコンパイル・ビルドするのが定石でしょうか。

Makefile
.PHONY: build-native build-linux-x86 build-linux-arm build-all

##### Build for native platform (筆者はmacos) #####
build-native:
	uvx maturin build --release --out dist

##### Build for linux x86_64 #####
# 補足:
# - maturinのDockerイメージはデフォルトで/ioディレクトリをワーキングディレクトリとして想定する
# - よって/ioをマウントすることでホストの`/dist`にもビルドされる
# (参考: https://github.com/PyO3/maturin/blob/d6d23cf97d19c327b10e51a1f7b6b87f662464b6/Dockerfile#L57)
build-linux-x86:
	docker run --rm -v $(shell pwd):/io \
		--platform linux/amd64 \
		ghcr.io/pyo3/maturin:latest \
		build --release --out dist --target x86_64-unknown-linux-gnu

##### Build for linux aarch64 #####
build-linux-arm:
	docker run --rm -v $(shell pwd):/io \
		--platform linux/arm64 \
		ghcr.io/pyo3/maturin:latest \
		build --release --out dist --target aarch64-unknown-linux-gnu

##### Build All #####
build-all: build-native build-linux-x86 build-linux-arm
	@echo "All wheels built."
	@ls -lh dist/

make build-all実行後は以下のように複数のWheelが生成されます。

dist/
├── pyo3_sf_demo_greeter-0.1.0-cp39-cp39-macosx_11_0_arm64.whl
├── pyo3_sf_demo_greeter-0.1.0-cp39-cp39-manylinux_2_17_x86_64.whl
└── pyo3_sf_demo_greeter-0.1.0-cp39-cp39-manylinux_2_17_aarch64.whl

WheelファイルはそのままSnowflake UDFで使えない -> zipの作成

これは検証の過程で分かったことなのですが、SnowflakeのUDF作成のIMPORTS句を使う場合はWheelファイルのままだとmoduleとして認識されないためzipファイルにしておく必要がありました。

Snowflakeのドキュメンテーション明示されているわけではありませんが、以下の箇所が該当の情報になりそうです。
https://docs.snowflake.com/ja/developer-guide/udf/python/udf-python-limitations#general-limitations

SnowflakeはPython zipimport モジュールを使用して、ステージからPythonコードをインポートします。その結果、 zipimport の制限もUDFsに存在します。 zipimport の詳細については、 zipimportリファレンス をご参照ください。

こちらはNotebookの説明にはなりますが、 wheelファイルはContainer Runtimeのみでサポートされることが書いてありました。
https://docs.snowflake.com/ja/user-guide/ui-snowsight/notebooks-work-with-files

ノートブックで Python パッケージとして使用するためにファイルをアップロードする場合、Warehouse Runtime 上で実行する場合は .py と .zip のファイルのみがサポートされていることを考慮してください。Container Runtimeでは、 .whl (wheel)ファイルもサポートされています。パッケージを .zip ファイルとしてインポートする場合、Python パッケージであることを示す init.py ファイルがルートにあることを確認してください。

よってMakefileに以下を記載しそれぞれpyo3-sf-demo-greeter-x86.zipとpyo3-sf-demo-greeter-aarch.zipを作成しておきます。

Makefile
##### ZIP for x86_64 #####
zip-x86: build-linux-x86
	@echo "Creating ZIP for x86_64..."
	@rm -rf /tmp/pyo3-sf-demo-greeter-extract
	@mkdir -p /tmp/pyo3-sf-demo-greeter-extract
	@cd /tmp/pyo3-sf-demo-greeter-extract && \
		unzip -q $(shell pwd)/dist/*-manylinux_2_17_x86_64*.whl
	@cd /tmp/pyo3-sf-demo-greeter-extract && \
		zip -r $(shell pwd)/dist/pyo3-sf-demo-greeter-x86.zip pyo3_sf_demo_greeter/
	@rm -rf /tmp/pyo3-sf-demo-greeter-extract
	@echo "Created: dist/pyo3-sf-demo-greeter-x86.zip"

##### ZIP for aarch64 #####
zip-arm: build-linux-arm
	@echo "Creating ZIP for aarch64..."
	@rm -rf /tmp/pyo3-sf-demo-greeter-extract
	@mkdir -p /tmp/pyo3-sf-demo-greeter-extract
	@cd /tmp/pyo3-sf-demo-greeter-extract && \
		unzip -q $(shell pwd)/dist/*-manylinux_2_17_aarch64*.whl
	@cd /tmp/pyo3-sf-demo-greeter-extract && \
		zip -r $(shell pwd)/dist/pyo3-sf-demo-greeter-aarch.zip pyo3_sf_demo_greeter/
	@rm -rf /tmp/pyo3-sf-demo-greeter-extract
	@echo "Created: dist/pyo3-sf-demo-greeter-aarch.zip"

##### ZIP All #####
zip-all: zip-x86 zip-arm
	@echo "All ZIP files created:"
	@ls -lh dist/*.zip

Snowflake Stage / PyPIへのアップロード

次に、ビルドしたパッケージを実際にSnowflakeでUDFとして使用するため、Snowflake StageとPyPIそれぞれにアップロードしていきます。

A. Snowflake Stageに直接アップロード

Snowflake CLIを使って実行します。
まず、テスト用のデータベースとステージを作成します。今回はx86_64とaarch64の両アーキテクチャのzipファイル(中身はwheelと同じ)をアップロードしておきます。

-- テスト用のDBとスキーマを作成
CREATE OR REPLACE DATABASE tmp_pyo3_test;
CREATE OR REPLACE SCHEMA tmp_pyo3_test;
USE DATABASE tmp_pyo3_test;
USE SCHEMA tmp_pyo3_test;

-- wheelを配置するinternal stageを作成
CREATE OR REPLACE STAGE tmp_pyo3_test_stage;

-- x86_64(Intel/AMD)用のパッケージをアップロード
-- <path>/<to>は実際のパスに置換してください
PUT file:///<path>/<to>/dist/pyo3-sf-demo-greeter-x86.zip
  @tmp_pyo3_test_stage;

-- aarch64(ARM)用のパッケージをアップロード
PUT file:///<path>/<to>/dist/pyo3-sf-demo-greeter-aarch.zip
  @tmp_pyo3_test_stage;

-- アップロードしたwheelを確認
LIST @tmp_pyo3_test_stage;

B. PyPIにアップロード

PyPIへのアップロードにはtwineを使用します。まずPyPIでアカウントを作成し、API Tokenを取得します。こちらはwheelをそのままアップロードでOKです。

取得したTokenを環境変数に設定してアップロードします:

export TWINE_USERNAME=__token__
export TWINE_PASSWORD="your-pypi-api-token-here"
uvx twine upload dist/*.whl

これでSnowflake Stageへの直接アップロードとPyPI経由の配布、両方の準備が整いました。次のセクションでは、実際にUDFを作成して動作確認を行います。

実行・検証

A. Snowflake Stageからの実行

ひとまず実行 -> アーキテクチャ不一致によるエラー

まず特に何も指定せず、通常のMEDIUMのWarehouseでIMPORTS句にアップロードしたZIPパッケージを指定してみます。

CREATE OR REPLACE WAREHOUSE standard_wh WITH
WAREHOUSE_SIZE = 'MEDIUM';

USE WAREHOUSE standard_wh;

CREATE OR REPLACE FUNCTION greet_from_rust(name STRING)
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.12'
IMPORTS = ('@tmp_pyo3_test_stage/pyo3-sf-demo-greeter-x86.zip')
HANDLER = 'udf_handler'
AS $$
from pyo3_sf_demo_greeter import greet

def udf_handler(name):
    return greet(name)
$$;

-- 実行
SELECT greet_from_rust('Snowflake');

結果:エラー発生

Traceback (most recent call last):
  File "_udf_code.py", line 2, in <module>
    from pyo3_sf_demo_greeter import greet
  File "/home/udf/0/pyo3-sf-demo-greeter-x86.zip/pyo3_sf_demo_greeter/__init__.py", line 1, in <module>
    from ._core import greet
ModuleNotFoundError: No module named 'pyo3_sf_demo_greeter._core'

エラーメッセージを見ると、ZIP内の__init__.pyまでは読み込めていますが、Rustでコンパイルした.soファイル(_coreモジュール)が認識されていません。

Warehouseのアーキテクチャとcompileしたbinaryのアーキテクチャの不一致を疑い、WahouseをSHOW WAREHOUSES;で確認するとresource_constraintがSTANDARD_GEN_1になっていることを確認できました。
そしてどうやら、このSTANDARDのWarehouseのアーキテクチャは時間を通して変わってきているようで、現在は aarch64(ARM)になっていると推測されるようです (GEN_2も同様)。
https://medium.com/snowflake-engineering/deep-dive-inside-snowflakes-new-gen2-standard-warehouses-powered-by-aws-graviton3-6aacca73ae2d

x86のアーキテクチャのWarehouseが明示的に欲しい場合、Warehouse作成時にまずx86のCPUアーキテクチャを選ぶ必要がありそうです。
以下を参考に、RESOURCE_CONSTRAINTにMEMORY_1X_x86やMEMORY_16X_x86など_x86のつく値を設定する必要がありそうです。また、このRESOURCE_CONSTRAINTの設定はSnowpark-Optimized Warehouseのみになるようなので、実質x86のアーキテクチャを指定するにはSnowpark-Optimized Warehouseが必須になりそうです。

https://docs.snowflake.com/ja/user-guide/warehouses-snowpark-optimized#configuration-options-for-snowpark-optimized-warehouses

また、UDFを作成する際にも同様にRESOURCE_CONSTRAINTパラメータでアーキテクチャを明示的に指定する必要があることが以下の公式ドキュメントからもわかりました。

パッケージがx86専用に構築されている場合は、次の例のように、x86 CPU アーキテクチャを使用するウェアハウス(MEMORY_1X_x86 または MEMORY_16X_x86)のいずれかを選択してから RESOURCE_CONSTRAINT=(architecture='x86') を指定します。

https://docs.snowflake.com/ja/developer-guide/udf/python/udf-python-packages#packages-built-only-for-x86

x86指定でトライ

以下のコマンドでまずはx86を指定したWarehouseを作成します:

CREATE OR REPLACE WAREHOUSE snowpark_opt_wh WITH
  WAREHOUSE_SIZE = 'MEDIUM'
  WAREHOUSE_TYPE = 'SNOWPARK-OPTIMIZED'
  RESOURCE_CONSTRAINT = 'MEMORY_1X_x86'; -- x86指定

次にUDF定義にRESOURCE_CONSTRAINT=(architecture='x86')を追加します:

USE WAREHOUSE snowpark_opt_wh;

CREATE OR REPLACE FUNCTION greet_from_rust(name STRING)
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.12'
IMPORTS = ('@tmp_pyo3_test_stage/pyo3-sf-demo-greeter-x86.zip')
RESOURCE_CONSTRAINT=(architecture='x86')  -- ネイティブコード実行に必要
HANDLER = 'udf_handler'
AS $$
from pyo3_sf_demo_greeter import greet

def udf_handler(name):
    return greet(name)
$$;

SELECT greet_from_rust('Snowflake');

結果:成功

Hello, Snowflake! 🦀
Running on: Ubuntu 22.04 (UDF)

Rustで実装した関数がSnowflake UDF内で正常に動作しました!システム情報も正しく取得できており、ネイティブコードが実行環境内で問題なく動作していることが確認できます。

STANDARDがARMということでaarch向けのパッケージをトライ

標準Warehouse(STANDARD_GEN_1やSTANDARD_GEN_2)がARMアーキテクチャで動作していることが分かったので、念のためaarch64(ARM)向けにビルドしたZIPパッケージでも試してみます。

Warehouse自体がARMで動作しているのであれば、ARM向けにコンパイルした.soファイルも動作するのではないかという期待です。

-- 標準Warehouseを使用(ARM アーキテクチャ)
USE WAREHOUSE standard_wh;

CREATE OR REPLACE FUNCTION greet_from_rust_arm(name STRING)
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.12'
IMPORTS = ('@tmp_pyo3_test_stage/pyo3-sf-demo-greeter-aarch.zip')
HANDLER = 'udf_handler'
AS $$
from pyo3_sf_demo_greeter import greet

def udf_handler(name):
    return greet(name)
$$;

SELECT greet_from_rust_arm('Snowflake');

結果:エラー

Traceback (most recent call last):
  File "_udf_code.py", line 2, in <module>
    from pyo3_sf_demo_greeter import greet
  File "/home/udf/0/pyo3-sf-demo-greeter-aarch.zip/pyo3_sf_demo_greeter/__init__.py", line 1, in <module>
    from ._core import greet
ModuleNotFoundError: No module named 'pyo3_sf_demo_greeter._core'

残念ながら、ARM向けにビルドしたパッケージでも同じエラーが発生しました。
さらに、UDF定義でRESOURCE_CONSTRAINT=(architecture='aarch')のような指定を試みても、以下のエラーが発生します(aarch64, defaultなども同じ):

invalid value 'AARCH' for property 'ARCHITECTURE'

つまり、Python UDFのIMPORTS句でネイティブコードを読み込む際は、Warehouse自体がARMアーキテクチャで動作していても、x86向けにビルドしたバイナリのみが実行できるというのが現状のようです。そして、そのx86のバイナリを実行するためには、Snowpark-Optimized Warehouseでx86アーキテクチャを明示的に指定する必要があります。

発見・重要なポイント

  1. Warehouse作成時とUDF作成時の両方でアーキテクチャ指定が必要

    • Warehouse: RESOURCE_CONSTRAINT = 'MEMORY_1X_x86'
    • UDF: RESOURCE_CONSTRAINT=(architecture='x86')
    • 両方を一致させる必要がある
  2. x86アーキテクチャを指定するにはSnowpark-Optimized Warehouseが必須

    • 標準Warehouse(STANDARD)では_x86のRESOURCE_CONSTRAINTを指定できない
    • WAREHOUSE_TYPE = 'SNOWPARK-OPTIMIZED'の指定が必要
  3. aarch64(ARM)向けのネイティブコードは現時点では使用不可

    • 標準WarehouseがARMアーキテクチャでも、UDFのIMPORTSではARMバイナリを読み込めなかった
    • UDF作成時にRESOURCE_CONSTRAINT=(architecture='aarch64')などの指定も不可で現状はarchitecture='x86'のみが有効な値

B. PyPI経由での実行

最後に、PyPIにアップロードしたパッケージを使用する方法を試してみます。
ARTIFACT_REPOSITORYとPACKAGESを指定し、今回はアーキテクチャなどを意識せずに、Snowpark-optimizedでもない通常のWarhouseで実行します。

CREATE OR REPLACE FUNCTION greet_from_rust_pypi(input STRING)
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.12'
ARTIFACT_REPOSITORY = snowflake.snowpark.pypi_shared_repository
PACKAGES = ('pyo3-sf-demo-greeter==0.1.0')
HANDLER = 'udf_handler'
AS $$
from pyo3_sf_demo_greeter import greet

def udf_handler(input):
    return greet(input)
$$;

-- 実行
SELECT greet_from_rust_pypi('Snowflake');

結果:成功

Hello, Snowflake! 🦀
Running on: Ubuntu 22.04 (UDF)

この通りPyPI経由の場合はSnowpark-Optimized WarehouseやRESOURCE_CONSTRAINTの指定なし、通常のWarehouseで問題なく実行できています。

前章ではPyPIに複数のアーキテクチャ向けのWheelファイルをアップロードしました:

  • pyo3_sf_demo_greeter-0.1.0-cp39-abi3-manylinux_2_17_x86_64.whl
  • pyo3_sf_demo_greeter-0.1.0-cp39-abi3-manylinux_2_17_aarch64.whl

これにより、Snowflakeが内部的に実行環境に適したWheelを自動選択し、適切にインストールしてくれるため、ユーザー側でアーキテクチャを意識する必要がここではないのだと思います。

アプローチの比較とまとめ

項目 A. Snowflake Stage (ZIP) B. PyPI
セットアップ Stageへのアップロード PyPIへのpublish
ファイル形式 ZIP形式に変換が必要 Wheel形式のまま
Warehouse要件 Snowpark-Optimized必須 (RESOURCE_CONSTRAINTをサポートしているため) 通常のWarehouseでOK
RESOURCE_CONSTRAINT バイナリに合う指定がwarehouseとudf作成時に必要(今回はx86) 指定不要
適用シーン 社内限定・テスト用 公開パッケージ

どちらのアプローチも動作させることに成功しましたが、アーキテクチャなどを気にせず通常のPythonパッケージ同様にPyPIへアップロードすることのみを気にしていればいいため、PyPI経由の方が圧倒的にパッケージの運用・管理がしやすいかと思います。

一方、アーキテクチャのケアやZIP化など追加のStepがありますが、社内限定の用途、PyPIに公開したくない場合はStage経由が適していると言えそうです。Snowlake UDFは現在test.pypiやプライベートリポジトリをARTIFACT_REPOSITORYに指定することをサポートしていないので、テストをする場合などにも有効そうです。

まとめ

本記事では、RustコードをPyO3でPythonパッケージ化し、Snowflake UDFとして動作させる方法を探索しました。試行錯誤を通じて、SnowflakeのStageに直接アップロードしてUDFでLoadする方法でもPyPIでも動作させることができました。

企業での実用性

企業でSnowflakeを利用する際、パブリックなPyPIにパッケージをアップロードすることが難しいケースは多々あります。今回直接ビルド・コンパイルしたパッケージをStage経由でアップロードしてUDFで使用できることが確認できたのは良かったです。

一方で、将来的にSnowflakeにおいてPyPIだけではなくプライベートリポジトリからのパッケージのインストールも可能になった場合、そのアプローチの方がよりシンプルで管理しやすくなりそうです。

次に調査してみたいこと

今回は「動作する」ことの確認に重点を置きましたが、次のステップとして以下のような検証が面白そうなので続編としてどこかで書いてみたいと思います:

  • 実際のパフォーマンスクリティカルなコードを利用したPure PythonとRustのSnowflake UDF上のパフォーマンス比較
  • 冒頭にて触れた外部関数やSnowpark Container Servicesで実装した場合とのパフォーマンス比較
Finatext Tech Blog
Finatext Tech Blog

Discussion