Snowpark Python DB-API를 사용하여 외부 데이터 소스에서 데이터 읽기¶

DB-API 매개 변수¶

DB-API를 사용하여 Snowpark 클라이언트에서 SQL 서버에 연결하기¶

Snowpark에서 SQL 서버에 연결하려면 다음의 세 가지 패키지가 필요합니다.

• Snowpark: `snowflake-snowpark-python[pandas]<https://pypi.org/project/snowflake-snowpark-python/>`_

• SQL 서버 ODBC 드라이버: `Microsoft ODBC 드라이버(SQL Server용)<https://learn.microsoft.com/en-us/sql/connect/odbc/microsoft-odbc-driver-for-sql-server>`_. 드라이버를 설치하면 Microsoft의 EULA에 동의하는 것입니다.

• 오픈 소스 pyodbc 라이브러리: `pyodbc<https://pypi.org/project/pyodbc/>`_

아래는 Snowpark 클라이언트 및 저장 프로시저에서 SQL에 연결하는 데 필요한 코드 예제입니다.

• Python SQL 드라이버 설치하기

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
  brew tap microsoft/mssql-release https://github.com/Microsoft/homebrew-mssql-release
  brew update
  HOMEBREW_ACCEPT_EULA=Y brew install msodbcsql18 mssql-tools18

Copy

• snowflake-snowpark-python[pandas] 및 pyodbc 설치하기

pip install snowflake-snowpark-python[pandas]
pip install pyodbc

Copy

• SQL 서버에 연결하기 위한 팩토리 메서드 정의하기

def create_sql_server_connection():
    import pyodbc
    HOST = "mssql_host"
    PORT = "mssql_port"
    USERNAME = "mssql_username"
    PASSWORD = "mssql_password"
    DATABASE = "mssql_db"
    connection_str = (
        "DRIVER={{ODBC Driver 18 for SQL Server}};"
        "SERVER={HOST},{PORT};"
        "DATABASE={DATABASE};"
        "UID={USERNAME};"
        "PWD={PASSWORD};"
    )
    connection = pyodbc.connect(connection_str)
    return connection


# Call dbapi to pull data from mssql_table

df = session.read.dbapi(
  create_sql_server_connection,
    table="mssql_table")

Copy

DB-API를 사용하여 저장 프로시저에서 SQL 서버에 연결하기¶

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙, 외부 액세스 통합을 구성합니다.

  CREATE OR REPLACE SECRET mssql_secret
    TYPE = PASSWORD
    USERNAME = 'mssql_username'
    PASSWORD = 'mssql_password';
  
  -- Configure a network rule to allow egress to the source endpoint
  
  CREATE OR REPLACE NETWORK RULE mssql_network_rule
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = ('mssql_host:mssql_port');
  
  -- Configure an external access integration
  
  CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION mssql_access_integration
    ALLOWED_NETWORK_RULES = (mssql_network_rule)
    ALLOWED_AUTHENTICATION_SECRETS = (mssql_secret)
    ENABLED = true;
  
  -- Create or replace a Python stored procedure
  
  CREATE OR REPLACE PROCEDURE sp_mssql_dbapi()
    RETURNS TABLE()
    LANGUAGE PYTHON
    RUNTIME_VERSION='3.11'
    HANDLER='run'
    PACKAGES=('snowflake-snowpark-python', 'pyodbc', 'msodbcsql')
          EXTERNAL_ACCESS_INTEGRATIONS = (mssql_access_integration)
          SECRETS = ('cred' = mssql_secret )
  
  AS $$
  
  # Get user name and password from mssql_secret
  
  import _snowflake
  username_password_object = _snowflake.get_username_password('cred')
  USER = username_password_object.username
  PASSWORD = username_password_object.password
  
  # Define a method to connect to SQL server_hostname
  from snowflake.snowpark import Session
  def create_sql_server_connection():
      import pyodbc
  
      host = "mssql_host"
      port = mssql_port
      username = USER
      password = PASSWORD
      database = "mssql_database"
      connection_str = (
        "DRIVER={{ODBC Driver 18 for SQL Server}};"
        "SERVER={host},{port};"
        "DATABASE={database};"
        "UID={username};"
        "PWD={password};"
      )
  
      connection = pyodbc.connect(connection_str)
      return connection
  
  def run(session: Session):
      df = session.read.dbapi(
          create_sql_server_connection,
          table="mssql_table"
      )
      return df
  $$;
  
  CALL sp_mssql_dbapi();
  

  Copy

DB-API를 사용하여 Snowpark 클라이언트에서 Oracle에 연결하기¶

• snowflake-snowpark-python[pandas] 및 oracledb 설치하기

  pip install snowflake-snowpark-python[pandas]
  pip install oradb
  

  Copy

• DB-API를 사용하여 Oracle에서 데이터를 가져오고 Oracle에 연결하기 위한 팩토리 메서드 정의하기

  def create_oracle_db_connection():
      import oracledb
      HOST = "myhost"
      PORT = "myport"
      SERVICE_NAME = "myservice"
      USER = "myuser"
      PASSWORD = "mypassword"
      DSN = "{HOST}:{PORT}/{SERVICE_NAME}"
      connection = oracledb.connect(
          user=USER,
          password=PASSWORD,
          dsn=DSN
      )
      return connection
  
  
  # Call dbapi to pull data from mytable
  
  df = session.read.dbapi(
    create_oracle_db_connection,
    table="mytable")
  

  Copy

DB-API를 사용하여 저장 프로시저에서 Oracle에 연결하기¶

Snowflake를 소스 엔드포인트에 연결할 수 있도록 하려면 외부 액세스 통합이 필요합니다.

참고

:ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

  -- Configure the secret, a network rule to allow egress to the source endpoint and external access integration.
  
  CREATE OR REPLACE SECRET ora_secret
    TYPE = PASSWORD
    USERNAME = 'ora_username'
    PASSWORD = 'ora_password';
  
  -- Configure a network rule to allow egress to the source endpoint
  
  CREATE OR REPLACE NETWORK RULE ora_network_rule
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = ('ora_host:ora_port');
  
  -- Configure an external access integration
  
  CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION ora_access_integration
    ALLOWED_NETWORK_RULES = (ora_network_rule)
    ALLOWED_AUTHENTICATION_SECRETS = (ora_secret)
    ENABLED = true;
  

  Copy

CREATE OR REPLACE PROCEDURE sp_ora_dbapi()
  RETURNS TABLE()
  LANGUAGE PYTHON
  RUNTIME_VERSION='3.11'
  HANDLER='run'
  PACKAGES=('snowflake-snowpark-python', 'oracledb')
  EXTERNAL_ACCESS_INTEGRATIONS = (ora_access_integration)
  SECRETS = ('cred' = ora_secret )
AS $$

# Get user name and password from ora_secret
import _snowflake
username_password_object = _snowflake.get_username_password('cred')
USER = username_password_object.username
PASSWORD = username_password_object.password

# Define the factory method for creating a connection to Oracle

from snowflake.snowpark import Session

def create_oracle_db_connection():
    import oracledb
    host = "ora_host"
    port = "ora_port"
    service_name = "ora_service"
    user = USER
    password = PASSWORD
    DSN = "{host}:{port}/{service_name}"
    connection = oracledb.connect(
        user=USER,
        password=PASSWORD,
        dsn=DSN
    )
    return connection

def run(session: Session):
    df = session.read.dbapi(
        create_ora_connection,
        table="ora_table"
    )
    return df
$$;

CALL sp_ora_dbapi();

DB-API를 사용하여 Snowflake Notebook에서 Oracle에 연결하기¶

• Notebook 패키지에서 snowflake-snowpark-python 및 :code:`oracledb`를 선택합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

  CREATE OR REPLACE SECRET ora_secret
    TYPE = PASSWORD
    USERNAME = 'ora_username'
    PASSWORD = 'ora_password';
    ALTER NOTEBOOK mynotebook SET SECRETS = ('snowflake-secret-object' = ora_secret);
  
  -- Configure a network rule to allow egress to the source endpoint
  
  CREATE OR REPLACE NETWORK RULE ora_network_rule
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = ('ora_host:ora_port');
  
  -- Configure an external access integration.
  
  CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION ora_access_integration
    ALLOWED_NETWORK_RULES = (ora_network_rule)
    ALLOWED_AUTHENTICATION_SECRETS = (ora_secret)
    ENABLED = true;
  

  Copy

• :doc:`/user-guide/ui-snowsight/notebooks-external-access`를 클릭한 후 Notebook 세션을 다시 시작합니다.

DB-API를 사용하여 Snowpark 클라이언트에서 PostgreSQL에 연결하기¶

• psycopg2 설치하기

  pip install psycopg2
  

  Copy

• PostgreSQL에 연결하기 위한 팩토리 메서드 정의하기

  def create_pg_connection():
      import psycopg2
      connection = psycopg2.connect(
          host="pg_host",
          port=pg_port,
          dbname="pg_dbname",
          user="pg_user",
          password="pg_password",
      )
      return connection
  
  
  # Call dbapi to pull data from pg_table
  
  df = session.read.dbapi(
    create_pg_connection,
    table="pg_table")
  

  Copy

DB-API를 사용하여 저장 프로시저에서 PostgreSQL에 연결하기¶

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

CREATE OR REPLACE SECRET pg_secret
  TYPE = PASSWORD
  USERNAME = 'pg_username'
  PASSWORD = 'pg_password';

-- Configure a network rule.

CREATE OR REPLACE NETWORK RULE pg_network_rule
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('pg_host:pg_port');

-- Configure an external access integration.

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION pg_access_integration
  ALLOWED_NETWORK_RULES = (pg_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (pg_secret)
  ENABLED = true;

• Snowpark Python DB-API를 사용하여 Python 저장 프로시저의 PostgreSQL에서 데이터 가져오기

CREATE OR REPLACE PROCEDURE sp_pg_dbapi()
RETURNS TABLE()
LANGUAGE PYTHON
RUNTIME_VERSION='3.11'
HANDLER='run'
PACKAGES=('snowflake-snowpark-python', 'psycopg2')
EXTERNAL_ACCESS_INTEGRATIONS = (pg_access_integration)
SECRETS = ('cred' = pg_secret )
AS $$

# Get user name and password from pg_secret

import _snowflake
username_password_object = _snowflake.get_username_password('cred')
USER = username_password_object.username
PASSWORD = username_password_object.password

# Define the factory method for creating a connection to PostgreSQL

from snowflake.snowpark import Session

def create_pg_connection():
    import psycopg2
    connection = psycopg2.connect(
        host="pg_host",
        port=pg_port,
        dbname="pg_dbname",
        user=USER,
        password=PASSWORD,
    )
    return connection

def run(session: Session):
    df = session.read.dbapi(
        create_pg_connection,
        table="pg_table"
    )
    return df

$$;
CALL sp_pg_dbapi();

DB-API를 사용하여 Snowflake Notebook에서 PostgreSQL에 연결하기¶

• Snowflake Notebook 패키지</user-guide/ui-snowsight/notebooks-import-packages>`에서 :code:`snowflake-snowpark-python 및 :code:`psycopg2`를 선택합니다.

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

-- Configure the secret

CREATE OR REPLACE SECRET pg_secret
  TYPE = PASSWORD
  USERNAME = 'pg_username'
  PASSWORD = 'pg_password';
  ALTER NOTEBOOK pg_notebook SET SECRETS = ('snowflake-secret-object' = pg_secret);

 -- Configure the network rule to allow egress to the source endpoint

 CREATE OR REPLACE NETWORK RULE pg_network_rule
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = ('pg_host:pg_port');

 -- Configure external access integration

 CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION pg_access_integration
    ALLOWED_NETWORK_RULES = (pg_network_rule)
    ALLOWED_AUTHENTICATION_SECRETS = (pg_secret)
    ENABLED = true;

• :doc:`/user-guide/ui-snowsight/notebooks-external-access`를 클릭한 후 Notebook 세션을 다시 시작합니다.

  # Get the user name and password from :code:`pg_secret`
  
  import _snowflake
  username_password_object = _snowflake.get_username_password('snowflake-secret-object')
  USER = username_password_object.username
  PASSWORD = username_password_object.password
  
  import snowflake.snowpark.context
  session = snowflake.snowpark.context.get_active_session()
  
  # Define the factory method for creating a connection to PostgreSQL
  
  def create_pg_connection():
      import psycopg2
      connection = psycopg2.connect(
          host="pg_host",
          port=pg_port,
          dbname="pg_dbname",
          user=USER,
          password=PASSWORD,
      )
      return connection
  
  # Use dbapi to read and save data from pg_table
  
  df = session.read.dbapi(
      create_pg_connection,
      table="pg_table"
  )
  
  # Save data into sf_table
  
  df.write.mode("overwrite").save_as_table('sf_table')
  

  Copy

DB-API를 사용하여 Snowpark 클라이언트에서 MySQL에 연결하기¶

• pymysql 설치하기

pip install snowflake-snowpark-python[pandas]
pip install pymysql

Copy

• MySQL에 연결하기 위한 팩토리 메서드 정의하기

def create_mysql_connection():
    import pymysql
    connection = pymysql.connect(
        host="mysql_host",
        port=mysql_port,
        database="mysql_db",
        user="mysql_user",
        password="mysql_password"
    )
    return connection


# Call dbapi to pull data from mysql_table

df = session.read.dbapi(
    create_mysql_connection,
    table="mysql_table"
)

DB-API를 사용하여 저장 프로시저에서 MySQL에 연결하기¶

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

CREATE OR REPLACE SECRET mysql_secret
  TYPE = PASSWORD
  USERNAME = 'mysql_username'
  PASSWORD = 'mysql_password';

-- Configure a network rule.

CREATE OR REPLACE NETWORK RULE mysql_network_rule
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('mysql_host:mysql_port');

-- Configure an external access integration

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION mysql_access_integration
  ALLOWED_NETWORK_RULES = (mysql_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (mysql_secret)
  ENABLED = true;

• Snowpark Python DB-API를 사용하여 Python 저장 프로시저의 MySQL에서 데이터를 가져옵니다.

CREATE OR REPLACE PROCEDURE sp_mysql_dbapi()
RETURNS TABLE()
LANGUAGE PYTHON
RUNTIME_VERSION='3.11'
HANDLER='run'
PACKAGES=('snowflake-snowpark-python', 'pymysql')
EXTERNAL_ACCESS_INTEGRATIONS = (mysql_access_integration)
SECRETS = ('cred' = mysql_secret )
AS $$

# Get user name and password from mysql_secret

import _snowflake
    username_password_object = _snowflake.get_username_password('cred')
    USER = username_password_object.username
    PASSWORD = username_password_object.password

# Define the factory method for creating a connection to MySQL

from snowflake.snowpark import session

def create_mysql_connection():
    import pymysql
    connection = pymysql.connect(
        host="mysql_host",
        port=mysql_port,
        dbname="mysql_dbname",
        user=USER,
        password=PASSWORD,
    )
    return connection

def run(session: Session):
    df = session.read.dbapi(
        create_mysql_connection,
        table="mysql_table"
    )
    return df
$$;

CALL sp_mysql_dbapi();

DB-API를 사용하여 Snowflake Notebook에서 MySQL에 연결하기¶

• Snowflake Notebook 패키지에서 snowflake-snowpark-python 및 :code:`pymysql`을 선택합니다.

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿을 구성하고 :doc:`Snowflake Notebook</user-guide/ui-snowsight/notebooks>`에 추가합니다.

CREATE OR REPLACE SECRET mysql_secret
  TYPE = PASSWORD
  USERNAME = 'mysql_username'
  PASSWORD = 'mysql_password';

  ALTER NOTEBOOK mynotebook SET SECRETS = ('snowflake-secret-object' = mysql_secret);

• 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

CREATE OR REPLACE NETWORK RULE mysql_network_rule
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('mysql_host:mysql_port');

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION mysql_access_integration
  ALLOWED_NETWORK_RULES = (mysql_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (mysql_secret)
  ENABLED = true;

• :doc:`/user-guide/ui-snowsight/notebooks-external-access`를 클릭한 후 Notebook 세션을 다시 시작합니다.

# Get user name and password from mysql_secret
import _snowflake
username_password_object = _snowflake.get_username_password('snowflake-secret-object')
USER = username_password_object.username
PASSWORD = username_password_object.password

import snowflake.snowpark.context
session = snowflake.snowpark.context.get_active_session()

# Define the factory method for creating a connection to MySQL

def create_mysql_connection():
    import pymysql
    connection = pymysql.connect(
        host="mysql_host",
        port=mysql_port,
        dbname="mysql_dbname",
        user=USER,
        password=PASSWORD,
    )
    return connection

# Call dbapi to pull data from mysql_table

df = session.read.dbapi(
    create_mysql_connection,
    table="mysql_table")

# Save data into sf_table

df.write.mode("overwrite").save_as_table('sf_table')

DB-API를 사용하여 Snowpark 클라이언트에서 Databricks에 연결하기¶

• databricks-sql-connector 설치하기:

pip install snowflake-snowpark-python[pandas]
pip install databricks-sql-connector

• Databricks에 연결하기 위한 팩토리 메서드 정의하기

def create_dbx_connection():
    import databricks.sql
    connection = databricks.sql.connect(
        server_hostname=HOST,
        http_path=PATH,
        access_token=ACCESS_TOKEN
    )
    return connection


#Call dbapi to pull data from mytable

df = session.read.dbapi(
    create_dbx_connection,
    table="dbx_table")

DB-API를 사용하여 저장 프로시저에서 Databricks에 연결하기¶

• Snowflake Notebook 패키지</user-guide/ui-snowsight/notebooks-import-packages>`에서 :code:`snowflake-snowpark-python 및 :code:`pymysql`를 선택합니다.

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하려면 외부 액세스 통합이 필요합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿, 소스 엔드포인트로의 송신을 허용하는 네트워크 규칙 및 외부 액세스 통합을 구성합니다.

CREATE OR REPLACE SECRET dbx_secret
  TYPE = GENERIC_STRING
  SECRET_STRING = 'dbx_access_token';

-- Configure a network rule

CREATE OR REPLACE NETWORK RULE dbx_network_rule
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('dbx_host:dbx_port');

--  Configure an external access integration

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION dbx_access_integration
  ALLOWED_NETWORK_RULES = (dbx_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (dbx_secret)
  ENABLED = true;

• Snowpark Python DB-API를 사용하여 Python 저장 프로시저의 Databricks에서 데이터 가져오기

CREATE OR REPLACE PROCEDURE sp_dbx_dbapi()
  RETURNS TABLE()
  LANGUAGE PYTHON
  RUNTIME_VERSION='3.11'
  HANDLER='run'
  PACKAGES=('snowflake-snowpark-python', 'databricks-sql-connector')
  EXTERNAL_ACCESS_INTEGRATIONS = (dbx_access_integration)
  SECRETS = ('cred' = dbx_secret )
AS $$

# Get user name and password from dbx_secret

import _snowflake
ACCESS_TOKEN = _snowflake.get_generic_secret_string('cred')

from snowflake.snowpark import Session

# define the method for creating a connection to Databricks
def create_dbx_connection():
    import databricks.sql
    connection = databricks.sql.connect(
        server_hostname="dbx_host",
        http_path="dbx_path",
        access_token=ACCESS_TOKEN,
    )
    return connection

def run(session: Session):
    df = session.read.dbapi(
        create_dbx_connection,
        table="dbx_table"
    )
    return df

$$;

CALL sp_dbx_dbapi();

Copy

DB-API를 사용하여 Snowflake Notebook에서 Databricks에 연결하기¶

• Snowflake Notebook 패키지</user-guide/ui-snowsight/notebooks-import-packages>`에서 :code:`snowflake-snowpark-python 및 :code:`pymysql`를 선택합니다.

• Snowflake를 소스 엔드포인트에 연결할 수 있도록 하는 데 필요한 외부 액세스 통합을 구성합니다.

  참고

  :ref:`PrivateLink<label-aws_privatelink_connect>`는 특히 민감한 정보를 처리할 때 데이터를 안전하게 전송하기 위해 권장됩니다. Snowflake 계정에 필요한 PrivateLink 권한이 활성화되어 있는지, PrivateLink 기능이 구성되고 Snowflake Notebook 환경에 활성화되어 있는지 확인합니다.

• 시크릿을 구성하고 :doc:`Snowflake Notebook</user-guide/ui-snowsight/notebooks>`에 추가합니다.

  CREATE OR REPLACE SECRET dbx_secret
    TYPE = GENERIC_STRING
    SECRET_STRING = 'dbx_access_token';
    ALTER NOTEBOOK mynotebook SET SECRETS = ('snowflake-secret-object' = dbx_secret);
  

  Copy

• 구성

  CREATE OR REPLACE NETWORK RULE dbx_network_rule
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = ('dbx_host:dbx_port');
  
  CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION dbx_access_integration
    ALLOWED_NETWORK_RULES = (dbx_network_rule)
    ALLOWED_AUTHENTICATION_SECRETS = (dbx_secret)
    ENABLED = true;
  

  Copy

• :doc:`/user-guide/ui-snowsight/notebooks-external-access`를 클릭한 후 Notebook 세션을 다시 시작합니다.

  # Get user name and password from dbx_secret
  
  import _snowflake
  ACCESS_TOKEN = _snowflake.get_generic_secret_string('cred')
  
  import snowflake.snowpark.context
  session = snowflake.snowpark.context.get_active_session()
  
  # Define the factory method for creating a connection to Databricks
  
  def create_dbx_connection():
      import databricks.sql
      connection = databricks.sql.connect(
          server_hostname="dbx_host",
          http_path="dbx_path",
          access_token=ACCESS_TOKEN,
      )
      return connection
  
  # use dbapi to read data from dbx_table
  
  df = session.read.dbapi(
      create_dbx_connection,
      table="dbx_table"
  )
  
  # save data into sf_table
  
  df.write.mode("overwrite").save_as_table('sf_table')
  

  Copy

드라이버¶

Snowpark Python DB-API는 Python DB-API 2.0 호환 드라이버(예: pyodbc, oracledb)만 지원합니다. 이 릴리스에서는 JDBC 드라이버를 지원하지 않습니다.