Configurer l’accès externe pour Snowflake Notebooks¶

Lorsque vous travaillez avec des notebooks, vous pouvez être amené à appeler des services externes, qui nécessitent souvent des identifiants de connexion sensibles tels que les clés API. Pour assurer la sécurité des informations sensibles, vous pouvez utiliser des secrets gérés dans Snowflake au lieu de coder des identifiants en dur dans votre notebook.

Les Intégrations d’accès externe (EAI) sont configurées à l’aide de règles réseau et peuvent éventuellement utiliser des secrets Snowflake pour l’authentification.

Par défaut, Snowflake restreint le trafic réseau en provenance des points de terminaison externes. Pour accéder à des points de terminaison externes, procédez comme suit :

Créer une règle réseau.
Créez une intégration d’accès au réseau externe qui utilise la règle.
Créez un secret pour l’authentification (si nécessaire). Les secrets génériques sous forme de chaîne requièrent également une EAI.
Associez le secret à l’EAI.
Associez l’EAI et le secret au notebook.

Note

Les EAI et les règles réseau doivent être créées par un administrateur de l’organisation. Pour les privilèges requis, voir Exigences en matière de contrôle d’accès.

Configurer un notebook avec un accès externe et des secrets¶

Cet exemple de bout en bout montre comment configurer un notebook pour qu’il accède à l’API OpenAI à l’aide d’un secret de chaîne générique.

-- Step 1: Create a secret
CREATE SECRET openai_key
  TYPE = GENERIC_STRING
  SECRET_STRING = '<your-api-key>';

-- Step 2: Create a network rule
CREATE OR REPLACE NETWORK RULE openai_rule
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('api.openai.com');

-- Step 3: Create an external access integration that uses the network rule and secret
CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION openai_integration
  ALLOWED_NETWORK_RULES = (openai_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (openai_key)
  ENABLED = true;

-- Step 4: Associate the integration and secret with the notebook
ALTER NOTEBOOK my_notebook
  SET EXTERNAL_ACCESS_INTEGRATIONS = (openai_integration),
    SECRETS = ('openai_key' = openai_key);

Note

Les secrets doivent être associés à la fois à l’intégration d’accès externe (EAI) et au notebook. Si un secret n’est associé qu’à l’un des deux, il ne sera pas accessible à partir du code du notebook.

Accéder au secret d’un notebook¶

Après avoir associé le secret au notebook, pour accéder à sa valeur dans le code du notebook, utilisez l’objet st.secrets :

import streamlit as st
api_key = st.secrets['openai_key']

Exemples d’EAI supplémentaires¶

Ces exemples montrent comment mettre en place un accès externe pour les sites courants de science des données et de machine learning :

EAI pour PyPI¶

CREATE OR REPLACE NETWORK RULE pypi_network_rule
MODE = EGRESS
TYPE = HOST_PORT
VALUE_LIST = ('pypi.org', 'pypi.python.org', 'pythonhosted.org', 'files.pythonhosted.org');

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION pypi_access_integration
ALLOWED_NETWORK_RULES = (pypi_network_rule)
ENABLED = true;

EAI pour Hugging Face¶

CREATE OR REPLACE NETWORK RULE hf_network_rule
MODE = EGRESS
TYPE = HOST_PORT
VALUE_LIST = ('huggingface.co', 'cdn-lfs.huggingface.co');

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION hf_access_integration
ALLOWED_NETWORK_RULES = (hf_network_rule)
ENABLED = true;

Accordez les privilèges USAGE nécessaires pour utiliser les intégrations d’accès externe¶

Une fois les EAI créées, accordez le privilège USAGE sur l’intégration aux rôles qui les utiliseront :
```
GRANT USAGE ON INTEGRATION openai_integration TO ROLE my_notebook_role;
```

Le rôle utilisé pour créer le notebook doit avoir le privilège USAGE sur l’EAI. Accorder le privilège USAGE au rôle PUBLIC ne fonctionnera pas.

Activer les intégrations d’accès externe dans Snowsight¶

Après avoir créé et provisionné les EAI, redémarrez la session du notebook afin de voir les intégrations d’accès que vous avez créées dans le volet External Access.

Pour activer les intégrations à l’aide de Snowsight :

Dans le menu de navigation, sélectionnez Projects » Notebooks.
Ouvrez votre notebook.
Sélectionnez l’icône en haut à droite de votre notebook.
Sélectionnez Notebook settings puis sélectionnez External access.
Basculez sur les EAI que vous souhaitez activer pour le notebook.

Autres exemples d’authentification¶

Jeton d’accès OAuth¶

CREATE OR REPLACE SECRET oauth_token
    TYPE = OAUTH2
    API_AUTHENTICATION = google_translate_oauth
    OAUTH_REFRESH_TOKEN = 'my-refresh-token';

# Using the secret as part of an EAI
  ALTER NOTEBOOK google_translate_test
    SET EXTERNAL_ACCESS_INTEGRATIONS=(google_translate_integration)
      SECRETS = ('cred' = oauth_token);

Type de secret : GENERIC_STRING¶

Utilisez un secret GENERIC_STRING pour stocker une valeur unique, telle qu’une clé ou un jeton API.

Créez le secret :

CREATE SECRET sf_openai_key
  TYPE = GENERIC_STRING
  SECRET_STRING = '<string_literal>';

-- SQL: Associate the secret and EAI with the notebook
ALTER NOTEBOOK openai_test
  SET EXTERNAL_ACCESS_INTEGRATIONS = (openai_access_int),
    SECRETS = ('openai_key' = sf_openai_key);

Pour les secrets GENERIC_STRING, l’accès s’effectue par le biais d’un dictionnaire ou d’un attribut :

import streamlit as st

# Access the string value directly
my_openai_key = st.secrets['openai_key']
# or using attribute access
my_openai_key = st.secrets.openai_key

Type de secret : PASSWORD (exemple : GitHub Basic Auth)¶

Utilisez un secret PASSWORD pour stocker une paire nom d’utilisateur et mot de passe. Cette paire est souvent exigée pour l’authentification de base auprès d’AI externes.

Dans cet exemple, le notebook accède à l’API REST GitHub à l’aide d’un secret PASSWORD et d’une intégration d’accès externe.

Créez le secret :

CREATE SECRET password_secret
  TYPE = PASSWORD
  USERNAME = 'my_user_name'
  PASSWORD = 'my_password';

Utilisez le secret dans le cadre d’une EAI :

ALTER NOTEBOOK github_user_info
SET EXTERNAL_ACCESS_INTEGRATIONS = (github_access_int),
    SECRETS = ('cred' = password_secret);

Accédez au secret dans votre code :

import streamlit as st
import requests
from requests.auth import HTTPBasicAuth

# Access credentials from the secret
username = st.secrets.cred.username
password = st.secrets.cred.password

# Make an authenticated request
response = requests.get(
    'https://api.github.com/user',
    auth=HTTPBasicAuth(username, password)
)

print(response.status_code)
print(response.json())

Ressources supplémentaires¶

Pour une syntaxe détaillée, voir Aperçu de l’accès au réseau externe.
Pour plus d’informations sur l’utilisation de CREATE SECRET, voir Création d’un secret pour représenter les identifiants de connexion.
Pour des exemples supplémentaires d’EAIs, voir Exemples d’accès au réseau externe ou Configuration d’un accès externe pour Snowflake Notebooks sur Github.