Snowpark Container Services : exécution SQL¶

Options de configuration des identifiants¶

Snowflake recommande que les conteneurs d’application utilisent des identifiants de connexion fournis par Snowflake pour s’authentifier auprès de Snowflake lors de l’exécution de SQL. Bien qu’il soit possible d’utiliser d’autres identifiants de connexion en se connectant via une intégration d’accès externe (EAI), la connexion via une EAI traite le service comme s’il fonctionnait en dehors de Snowflake et se connecte à Snowflake via Internet.

Vous avez trois options pour vous connecter à Snowflake à partir d’un conteneur de service :

• Utiliser les informations d’identification de l’utilisateur du service fournies par Snowflake : Snowflake fournit chaque service avec des identifiants de connexion, qui sont appelés identifiants de connexion de service. Un service utilise ces identifiants de connexion pour se connecter à Snowflake en tant qu’utilisateur du service.

• Utiliser les identifiants de connexion de l’appelant fournis par Snowflake (droits de l’appelant) : lorsque vous configurez votre service avec les droits de l’appelant, Snowflake fournit également des identifiants de connexion pour que le service puisse se connecter à Snowflake en tant qu’utilisateur appelant.

• Utiliser d’autres identifiants de connexion : dans ce cas, vous utilisez une intégration d’accès externe (EAI) qui permet à votre service de se connecter au point de terminaison Internet de Snowflake en utilisant des identifiants de connexion valides. Cette option nécessite un administrateur pour créer le fichier d’EAI, puis accordez le privilège USAGE sur l’intégration au rôle de propriétaire de service.

  Note

  Si vous utilisez des intégrations d’accès externes pour accéder à Snowflake, vous pourriez envoyer des informations potentiellement sensibles sur Internet.

Pour des exemples de code qui utilisent divers pilotes Snowflake pour la connexion à Snowflake, voir Exemples de connexion Snowflake.

SNOWFLAKE_ACCOUNT = os.getenv('SNOWFLAKE_ACCOUNT')
SNOWFLAKE_HOST = os.getenv('SNOWFLAKE_HOST')

def get_login_token():
  with open('/snowflake/session/token', 'r') as f:
    return f.read()

conn = snowflake.connector.connect(
  host = os.getenv('SNOWFLAKE_HOST'),
  account = os.getenv('SNOWFLAKE_ACCOUNT'),
  token = get_login_token(),
  authenticator = 'oauth'
)

ALTER USER my_user SET DEFAULT_SECONDARY_ROLES = ( 'ALL' );

-- Permissions to resolve the table's name.
GRANT CALLER USAGE ON DATABASE <db_name> TO ROLE <service_owner_role>;
GRANT CALLER USAGE ON SCHEMA <schema_name> TO ROLE <service_owner_role>;
-- Permissions to use a warehouse
GRANT CALLER USAGE ON WAREHOUSE <warehouse_name> TO ROLE <service_owner_role>;
-- Permissions to query the table.
GRANT CALLER SELECT ON TABLE T1 TO ROLE <service_owner_role>;

conn = snowflake.connector.connect(
  account = '<acct-name>',
  user = '<user-name>',
  password = '<password>'
)

Configuration de la base de données et du contexte du schéma pour l’exécution de SQL¶

En plus de fournir des identifiants de connexion, Snowflake fournit également la base de données et le contexte de schéma dans lesquels le service est créé. Le code du conteneur peut utiliser ces informations pour exécuter SQL dans le même contexte de base de données et de schéma que le service.

Cette section présente deux concepts :

• La logique utilisée par Snowflake pour déterminer la base de données et le schéma dans lesquels créer votre service.

• La méthode par laquelle Snowflake transmet cette information à vos conteneurs, permettant ainsi au code du conteneur d’exécuter SQL dans le même contexte de base de données et de schéma.

Snowflake utilise le nom du service pour déterminer la base de données et le schéma dans lesquels créer un service :

• Exemple 1 : dans les commandes CREATE SERVICE et EXECUTE JOB SERVICE suivantes, le nom du service ne spécifie pas explicitement une base de données et un nom de schéma. Snowflake crée le service et le service de tâche dans la base de données et le schéma actuels.

  -- Create a service.
  CREATE SERVICE test_service IN COMPUTE POOL ...
  
  -- Execute a job service.
  EXECUTE JOB SERVICE
    IN COMPUTE POOL tutorial_compute_pool
    NAME = example_job_service ...
  

  Copy

• Exemple 2 : dans les commandes CREATE SERVICE et EXECUTE JOB SERVICE suivantes, le nom du service comprend une base de données et un nom de schéma. Snowflake crée le service et le service de tâche dans la base de données (test_db) et le schéma (test_schema) spécifiés, quel que soit le schéma actuel.

  -- Create a service.
  CREATE SERVICE test_db.test_schema.test_service IN COMPUTE POOL ...
  
  -- Execute a job service.
  EXECUTE JOB SERVICE
    IN COMPUTE POOL tutorial_compute_pool
    NAME = test_db.test_schema.example_job_service ...
  

  Copy

Lorsque Snowflake démarre un service, Snowflake fournit les informations relatives à la base de données et au schéma aux conteneurs en cours d’exécution en utilisant les variables d’environnement suivantes :

• SNOWFLAKE_DATABASE

• SNOWFLAKE_SCHEMA

Le code de votre conteneur peut utiliser des variables d’environnement dans le code de connexion pour déterminer la base de données et le schéma à utiliser, comme le montre cet exemple :

conn = snowflake.connector.connect(
  host = os.getenv('SNOWFLAKE_HOST'),
  account = os.getenv('SNOWFLAKE_ACCOUNT'),
  token = get_login_token(),
  authenticator = 'oauth',
  database = os.getenv('SNOWFLAKE_DATABASE'),
  schema = os.getenv('SNOWFLAKE_SCHEMA')
)

Exemple

Dans le tutoriel 2, vous créez un service de tâche Snowflake qui se connecte à Snowflake et exécute des instructions SQL. Les étapes suivantes résument la manière dont le code du tutoriel utilise les variables d’environnement :

1. Dans la configuration commune (voir la section Configuration commune), vous créez des ressources, notamment une base de données et un schéma. Vous définissez également la base de données et le schéma actuels pour la session :

   USE DATABASE tutorial_db;
   ...
   USE SCHEMA data_schema;
   

   Copy

2. Après avoir créé un service de tâche (exécution de EXECUTE JOB SERVICE), Snowflake démarre le conteneur et définit les variables d’environnement suivantes dans le conteneur en fonction de la base de données et du schéma actuels de la session :

   • SNOWFLAKE_DATABASE est défini sur « TUTORIAL_DB »

   • SNOWFLAKE_SCHEMA est défini sur « DATA_SCHEMA »

3. Le code de la tâche (voir main.py dans le tutoriel 2) lit ces variables d’environnement :

   SNOWFLAKE_DATABASE = os.getenv('SNOWFLAKE_DATABASE')
   SNOWFLAKE_SCHEMA = os.getenv('SNOWFLAKE_SCHEMA')
   

   Copy

4. Le code de la tâche définit la base de données et le schéma comme le contexte dans lequel exécuter les instructions SQL (fonction run_job() dans main.py) :

   {
      "account": SNOWFLAKE_ACCOUNT,
      "host": SNOWFLAKE_HOST,
      "authenticator": "oauth",
      "token": get_login_token(),
      "warehouse": SNOWFLAKE_WAREHOUSE,
      "database": SNOWFLAKE_DATABASE,
      "schema": SNOWFLAKE_SCHEMA
   }
   ...
   

   Copy

   Note

   SNOWFLAKE_ACCOUNT, SNOWFLAKE_HOST, SNOWFLAKE_DATABASE, SNOWFLAKE_SCHEMA sont des variables d’environnement que Snowflake génère pour le conteneur d’application, mais SNOWFLAKE_WAREHOUSE ne l’est pas (le code de l’application du tutoriel 2 a créé cette variable parce que Snowflake ne transmet pas de nom d’entrepôt à un conteneur).

Spécification de l’entrepôt pour votre conteneur¶

Si votre service se connecte à Snowflake pour exécuter une requête dans un entrepôt Snowflake, vous disposez des options suivantes pour spécifier un entrepôt :

• Spécifiez un entrepôt dans votre code d’application. Spécifiez un entrepôt dans le cadre de la configuration de la connexion lorsque vous démarrez une session Snowflake pour exécuter des requêtes dans votre code. Pour un exemple, voir le tutoriel 2.

• Spécifiez un entrepôt par défaut lors de la création d’un service. Spécifiez le paramètre facultatif QUERY_WAREHOUSE dans la commande CREATE SERVICE (ou EXECUTE JOB SERVICE) pour fournir un entrepôt par défaut. Si votre code d’application ne fournit pas d’entrepôt dans le cadre de la configuration de la connexion, Snowflake utilise l’entrepôt par défaut. Utilisez la commande ALTER SERVICE pour modifier l’entrepôt par défaut.

  Note

  L’entrepôt spécifié à l’aide du paramètre QUERY_WAREHOUSE est le paramètre par défaut uniquement pour l’utilisateur de service. Lorsque le service se connecte à Snowflake au nom d’un autre utilisateur — dans le contexte de scénario des droits de l’appelant, Snowflake utilise l’entrepôt par défaut de l’utilisateur.

Si vous spécifiez un entrepôt à l’aide des deux méthodes, c’est l’entrepôt spécifié dans le code d’application qui est utilisé.

Accéder à l’historique des requêtes des utilisateurs du service¶

Vous pouvez trouver les requêtes exécutées par votre service en tant qu’utilisateur du service en filtrant la fonction Vue QUERY_HISTORY ou QUERY_HISTORY où user_type est SNOWFLAKE_SERVICE.

Exemple 1 : récupérer les requêtes exécutées par un service.

SELECT *
FROM snowflake.account_usage.query_history
WHERE user_type = 'SNOWFLAKE_SERVICE'
AND user_name = '<service_name>'
AND user_database_name = '<service_db_name>'
AND user_schema_name = '<service_schema_name>'
order by start_time;

Dans la clause WHERE :

• user_name = '<service_name>' : Vous spécifiez le nom de service en tant que nom de l’utilisateur, car un service exécute des requêtes en tant qu’utilisateur de service et le nom de l’utilisateur de service est le même que le nom du service.

• user_type = 'SNOWFLAKE_SERVICE' et user_name = '<service_name>' : Cela limite le résultat de la requête à récupérer uniquement les requêtes exécutées par un service.

• user_database_name et user_schema_name : Pour un utilisateur de service, il s’agit de la base de données et du schéma du service.

Vous pouvez obtenir les mêmes résultats en appelant la fonction QUERY_HISTORY.

SELECT *
FROM TABLE(<service_db_name>.information_schema.query_history())
WHERE user_database_name = '<service_db_name>'
AND user_schema_name = '<service_schema_name>'
AND user_type = 'SNOWFLAKE_SERVICE'
AND user_name = '<service_name>'
order by start_time;

Dans la clause WHERE :

• user_type = 'SNOWFLAKE_SERVICE' et user_name = '<service_name>' limitent le résultat de la requête pour récupérer uniquement les requêtes exécutées par un service.

• Les noms user_database_name et user_schema_name (pour un utilisateur de service) sont la base de données et le schéma du service.

Exemple 2 : récupérer les requêtes exécutées par les services et les informations correspondantes sur les services.

SELECT query_history.*, services.*
FROM snowflake.account_usage.query_history
JOIN snowflake.account_usage.services
ON query_history.user_name = services.service_name
AND query_history.user_schema_id = services.service_schema_id
AND query_history.user_type = 'SNOWFLAKE_SERVICE'

La requête rejoint les vues QUERY_HISTORY et SERVICES pour récupérer des informations sur les requêtes et les services qui ont exécuté les requêtes. Remarques :

• Pour les requêtes exécutées par les services, le query_history.user_name est le nom de l’utilisateur du service, qui est le même que le nom du service.

• La requête joint les vues à l’aide des IDs de schémas (pas le nom des schémas) pour vous assurer que vous faites référence au même schéma, car si vous supprimez et recréez un schéma, l’ID du schéma change, mais le nom reste le même.

Vous pouvez ajouter des filtres facultatifs à la requête. Par exemple :

• Filtre query_history pour récupérer uniquement les services qui ont exécuté des requêtes spécifiques.

• Filtre services pour récupérer uniquement les requêtes exécutées par des services spécifiques.

Exemple 3 : pour chaque service, récupérer les informations sur l’utilisateur du service.

SELECT services.*, users.*
FROM snowflake.account_usage.users
JOIN snowflake.account_usage.services
ON users.name = services.service_name
AND users.schema_id = services.service_schema_id
AND users.type = 'SNOWFLAKE_SERVICE'

La requête joint les vues SERVICES et USERS dans le schéma ACCOUNT_USAGE permettant de récupérer les services et les informations sur les utilisateurs des services. Remarques :

• Lorsqu’un service exécute des requêtes, il exécute les requêtes en tant qu’utilisateur du service et le nom de l’utilisateur du service est le même que le nom du service. Par conséquent, vous spécifiez la condition de jointure : users.name = services.service_name.

• Les noms de service ne sont uniques qu’au sein d’un schéma. Par conséquent, la requête spécifie la condition de jointure (users.schema_id = services.service_schema_id) pour garantir que chaque utilisateur de service est associé au service spécifique auquel il appartient (et non à un autre service du même nom exécuté dans des schémas différents).