Introduction aux tâches¶

Limitations¶

• La taille maximale de calcul pour une tâche sans serveur est équivalente à un entrepôt virtuel XXLARGE.

Créer une tâche à l’aide du modèle de calcul sans serveur¶

Utilisez CREATE TASK pour définir la tâche. Ne pas inclure le paramètre WAREHOUSE.

Le rôle qui exécute la tâche doit avoir le privilège global EXECUTE MANAGED TASK. Pour plus d’informations, voir Sécurité des tâches.

L’exemple suivant crée une tâche qui s’exécute toutes les heures.

CREATE TASK SCHEDULED_T1
  SCHEDULE='60 MINUTES'
  AS SELECT 1;

from datetime import timedelta
from snowflake.core.task import Cron, Task

tasks = root.databases["TEST_DB"].schemas["TEST_SCHEMA"].tasks

task = tasks.create(
    Task(
        name="SCHEDULED_T1",
        definition="SELECT 1",
        schedule=timedelta(minutes=60),
        ),
    )

Coût et performances : tailles d’entrepôt¶

Pour garantir l’exécution efficace des tâches sans serveur, vous pouvez définir des tailles d’entrepôt minimales et maximales en définissant les paramètres suivants :

• SERVERLESS_TASK_MIN_STATEMENT_SIZE : la taille minimale de l’entrepôt pour des performances prévisibles (par défaut : XSMALL).

• SERVERLESS_TASK_MAX_STATEMENT_SIZE: la taille maximale de l’entrepôt pour éviter les coûts imprévus (par défaut : XXLARGE).

Une fois la tâche terminée, Snowflake examine les performances et ajuste les ressources de calcul pour les exécutions futures dans ces limites.

L’exemple suivant montre une tâche qui s’exécute toutes les 30 secondes, avec une taille minimale de l’entrepôt SMALL et une taille maximale d’entrepôt LARGE.

CREATE TASK SCHEDULED_T2
  SCHEDULE='30 SECONDS'
  SERVERLESS_TASK_MIN_STATEMENT_SIZE='SMALL'
  SERVERLESS_TASK_MAX_STATEMENT_SIZE='LARGE'
  AS SELECT 1;

from datetime import timedelta
from snowflake.core.task import Cron, Task

tasks = root.databases["TEST_DB"].schemas["TEST_SCHEMA"].tasks

task = tasks.create(
    Task(
        name="SCHEDULED_T2",
        definition="SELECT 1",
        schedule=timedelta(seconds=30),
        serverless_task_min_statement_size="SMALL",
        serverless_task_max_statement_size="LARGE",
        ),
    )

Intervalle d’accomplissement de la cible¶

Vous pouvez définir une cible plus précoce pour l’achèvement d’une tâche sans serveur. Un intervalle d’achèvement cible est nécessaire pour les tâches déclenchées sans serveur.

Lorsqu’elles sont définies, Snowflake estime et met à l’échelle les ressources pour qu’elles s’achèvent dans l’intervalle d’achèvement cible. Lorsqu’une tâche est déjà à sa taille maximale d’entrepôt et fonctionne trop longtemps, l’intervalle d’achèvement cible est ignoré.

Dans l’exemple suivant, une tâche s’exécute tous les jours à minuit, avec un objectif d’achèvement fixé à 2 heures du matin. L’heure de début et le fuseau horaire sont définis par USING CRON. Si la tâche atteint la plus grande taille d’entrepôt, elle peut s’exécuter pendant trois heures avant de déclencher un délai d’expiration.

CREATE TASK SCHEDULED_T3
  SCHEDULE='USING CRON 0 * * * * America/Los_Angeles'
  TARGET_COMPLETION_INTERVAL='120 MINUTE'
  SERVERLESS_TASK_MAX_STATEMENT_SIZE='LARGE'
  USER_TASK_TIMEOUT_MS = 10800000         -- (3 hours)
  SUSPEND_TASK_AFTER_NUM_FAILURES = 3
  AS SELECT 1;

from datetime import timedelta
from snowflake.core.task import Cron, Task

tasks = root.databases["TEST_DB"].schemas["TEST_SCHEMA"].tasks

task = tasks.create(
    Task(
        name="SCHEDULED_T3",
        definition="SELECT 1",
        schedule=Cron("0 * * * *", "America/Los_Angeles"),
        target_completion_interval=timedelta(minutes=120),
        serverless_task_max_statement_size="LARGE",
        user_task_timeout_ms=10800000,  # (3 hours)
        suspend_task_after_num_failures=3,
    ),
)

Sélectionner un entrepôt¶

Lorsque vous choisissez un entrepôt, tenez compte des éléments suivants :

• Consultez les meilleures pratiques dans Considérations relatives aux entrepôts.

• Analysez les temps d’exécution moyens des tâches à l’aide de différents entrepôts en fonction de la taille de l’entrepôt et du clustering. Pour plus d’informations, voir Durée de la tâche.

• Si l’entrepôt est partagé par plusieurs processus, tenez compte de l’impact de la tâche sur d’autres charges de travail.

Créer une tâche à l’aide du modèle de calcul géré par l’utilisateur¶

Utilisez CREATE TASK, et intégrez le paramètre WAREHOUSE.

Le rôle qui exécute la tâche doit avoir le privilège global EXECUTE MANAGED TASK. Pour plus d’informations, voir Sécurité des tâches.

L’exemple suivant crée une tâche qui s’exécute toutes les heures.

CREATE TASK SCHEDULED_T1
  WAREHOUSE='COMPUTE_WH'
  SCHEDULE='60 MINUTES'
  AS SELECT 1;

Création de tâches¶

La création de tâches nécessite un rôle avec au minimum les privilèges suivants :

Tâches en cours d’exécution¶

Après la création d’une tâche, le propriétaire de la tâche doit disposer des privilèges suivants pour que la tâche puisse être exécutée :

En outre, le rôle doit disposer des autorisations requises pour exécuter l’instruction SQL exécutée par la tâche.

Affichage de l’historique des tâches¶

Pour voir les tâches, vous devez disposer d’un ou de plusieurs des privilèges suivants :

• Le rôle ACCOUNTADMIN

• Le privilège OWNERSHIP sur la tâche

• Le privilège MONITOR EXECUTION global

Reprise ou suspension de tâches¶

En plus du propriétaire de la tâche, un rôle qui a le privilège OPERATE sur la tâche peut suspendre ou reprendre la tâche. Ce rôle doit avoir le privilège USAGE sur la base de données et le schéma qui contiennent la tâche. Aucun autre privilège n’est requis.

Lorsqu’une tâche est reprise, Snowflake vérifie que le rôle de propriétaire de la tâche a les privilèges énumérés dans Tâches en cours d’exécution

Créer un rôle personnalisé pour créer des tâches¶

Snowflake nécessite des autorisations différentes pour créer des tâches sans serveur et des tâches gérées par l’utilisateur.

Par exemple, pour créer des tâches gérées par l’utilisateur, créez un rôle personnalisé nommé warehouse_task_creation et accordez à ce rôle les privilèges CREATE TASK et USAGE sur l’entrepôt dans lequel le rôle peut créer des tâches.

USE SYSADMIN;

CREATE ROLE warehouse_task_creation
  COMMENT = 'This role can create user-managed tasks.';

from snowflake.core.role import Role

root.session.use_role("SYSADMIN")

my_role = Role(
    name="warehouse_task_creation",
    comment="This role can create user-managed tasks."
)
root.roles.create(my_role)

USE ACCOUNTADMIN;

GRANT CREATE TASK
  ON SCHEMA schema1
  TO ROLE warehouse_task_creation;

from snowflake.core.role import Securable

root.session.use_role("ACCOUNTADMIN")

root.roles['warehouse_task_creation'].grant_privileges(
    privileges=["CREATE TASK"], securable_type="schema", securable=Securable(name='schema1')
)

GRANT USAGE
  ON WAREHOUSE warehouse1
  TO ROLE warehouse_task_creation;

from snowflake.core.role import Securable

root.roles['warehouse_task_creation'].grant_privileges(
    privileges=["USAGE"], securable_type="warehouse", securable=Securable(name='warehouse1')
)

Comme exemple de rôle pouvant créer des tâches sans serveur ; créez un rôle personnalisé nommé serverless_task_creation et accordez au rôle le privilège CREATE TASK et le privilège EXECUTE MANAGED TASK de niveau compte.

USE SYSADMIN;

CREATE ROLE serverless_task_creation
  COMMENT = 'This role can create serverless tasks.';

from snowflake.core.role import Role

root.session.use_role("SYSADMIN")

my_role = Role(
    name="serverless_task_creation",
    comment="This role can create serverless tasks."
)
root.roles.create(my_role)

USE ACCOUNTADMIN;

GRANT CREATE TASK
  ON SCHEMA schema1
  TO ROLE serverless_task_creation;

from snowflake.core.role import Securable

root.session.use_role("ACCOUNTADMIN")

root.roles['serverless_task_creation'].grant_privileges(
    privileges=["CREATE TASK"], securable_type="schema", securable=Securable(name='schema1')
)

GRANT EXECUTE MANAGED TASK ON ACCOUNT
  TO ROLE serverless_task_creation;

root.roles['serverless_task_creation'].grant_privileges(
    privileges=["EXECUTE MANAGED TASK"], securable_type="account"
)

Créer un rôle personnalisé pour administrer les tâches¶

Créez un rôle personnalisé disposant du privilège EXECUTE TASK et attribuez ce rôle personnalisé à tout rôle de propriétaire de tâche afin de lui permettre de modifier ses propres tâches. Pour supprimer la possibilité d’exécuter la tâche du rôle de propriétaire de la tâche , révoquez ce rôle personnalisé à partir du rôle de propriétaire de la tâche.

Par exemple, créez un nom de rôle personnalisé taskadmin et accordez-lui le privilège EXECUTE TASK. Attribuez le rôle taskadmin à un rôle de propriétaire de tâche nommé myrole :

USE ROLE securityadmin;

CREATE ROLE taskadmin;

from snowflake.core.role import Role

root.session.use_role("securityadmin")

root.roles.create(Role(name="taskadmin"))

Définissez le rôle actif sur ACCOUNTADMIN avant d’accorder les privilèges au niveau du compte au nouveau rôle

USE ROLE accountadmin;

GRANT EXECUTE TASK, EXECUTE MANAGED TASK ON ACCOUNT TO ROLE taskadmin;

root.session.use_role("accountadmin")

root.roles['taskadmin'].grant_privileges(
    privileges=["EXECUTE TASK", "EXECUTE MANAGED TASK"], securable_type="account"
)

Définissez le rôle actif sur SECURITYADMIN pour montrer que ce rôle peut accorder un rôle à un autre rôle

USE ROLE securityadmin;

GRANT ROLE taskadmin TO ROLE myrole;

from snowflake.core.role import Securable

root.session.use_role("securityadmin")

root.roles['myrole'].grant_role(role_type="ROLE", role=Securable(name='taskadmin'))

Pour plus d’informations sur la façon de créer des rôles personnalisés et des hiérarchies de rôles, voir Configuration du contrôle d’accès.

Supprimer un rôle de propriétaire de tâche¶

Lorsque vous supprimez le rôle de propriétaire d’une tâche, la tâche transfère la propriété au rôle qui a supprimé le rôle de propriétaire. Lorsqu’une tâche transfère sa propriété, elle est automatiquement mise en pause et les nouvelles exécutions ne sont pas planifiées tant que le nouveau propriétaire n’a pas repris la tâche.

Si vous supprimez le rôle alors que la tâche est en cours d’exécution, le traitement de la tâche s’achève sous le rôle supprimé.

Contrôle d’accès¶

Le rôle de propriétaire de la tâche doit se voir attribuer le privilège IMPERSONATE sur l’utilisateur spécifié par EXECUTE AS USER, et l’utilisateur spécifié doit se voir attribuer le rôle de propriétaire de la tâche.

Lorsque la tâche s’exécute, le rôle principal de la session de la tâche sera le rôle de propriétaire de la tâche et les rôles secondaires par défaut de l’utilisateur seront activés. Les utilisateurs pourront changer de rôles principaux avec la commande:doc:USE ROLE </sql-reference/sql/use-role> et ajuster les rôles secondaires dans la session de la tâche avec la commande USE SECONDARY ROLES.

Partager des tâches en utilisant un utilisateur de service et un rôle¶

Dans les environnements de production, nous vous recommandons de créer un utilisateur de service distinct pour représenter votre équipe ou votre processus métier. Contrairement à l’exécution en tant qu’utilisateur existant d’un service ou en tant que personne, cette meilleure pratique contribue à sécuriser davantage le flux de travail :

• Lorsqu’une tâche s’exécute en tant qu’utilisateur de service dédié, elle n’a accès qu’aux privilèges prévus. Si au lieu de cela, un utilisateur se fait passer pour un utilisateur différent, il a accès à tous les privilèges associés à l’autre utilisateur, qui peuvent inclure des privilèges involontaires, y compris des privilèges d’utilisateur accordés après la création et la reprise de la tâche.

• Une tâche en cours d’exécution en tant qu’utilisateur peut être interrompue si la personne quitte le département ou l’organisation.

Exemples : Configurer l’utilisateur de service et le rôle d’équipe¶

1. À l’aide du rôle d’administrateur, définissez un utilisateur de service à utiliser pour la tâche.

   L’exemple suivant crée un utilisateur de service nommé task_user :

   USE ROLE ACCOUNTADMIN;
   CREATE USER task_user;
   

   Copy

2. Créez un rôle de tâche, puis attribuez-le à l’utilisateur de service :

   CREATE ROLE task_role;
   GRANT ROLE task_role to USER task_user;
   

   Copy

3. Autorisez le rôle de tâche à exécuter des requêtes pour le compte du rôle d’utilisateur d’équipe :

   GRANT IMPERSONATE ON USER task_user TO ROLE task_role;
   

   Copy

4. Accordez les privilèges appropriés au rôle de tâche.

   USE ROLE ACCOUNTADMIN;
   
   -- Grant the team role the privileges to create tasks in a specific schema
   GRANT CREATE TASK
     ON SCHEMA schema1
     TO ROLE task_role;
   
   -- Grant the team role the privileges to use a specific warehouse
   GRANT USAGE
     ON WAREHOUSE warehouse1
     TO ROLE task_role;
   
   -- Grant the team role the privileges to run tasks on a serverless compute model
   GRANT EXECUTE MANAGED TASK ON ACCOUNT TO ROLE task_role;
   

   Copy

Exécuter une tâche pour le compte d’un utilisateur de service¶

Une fois que le rôle d’équipe a la propriété de la tâche, les membres de l’équipe peuvent modifier la tâche et l’exécuter pour le compte de l’utilisateur de service.

Exemple :

USE ROLE task_owner;

CREATE TASK team_task
  SCHEDULE='12 HOURS'
  EXECUTE AS USER task_user
  AS SELECT 1;

Dans l’exemple précédent, les journaux créés montreraient que task_user a modifié la tâche.

(Pour les tests uniquement) Autoriser un utilisateur à se faire passer pour un autre utilisateur directement¶

Lorsque vous testez ou prototypez des modifications, vous, en tant qu’administrateur, pouvez permettre aux utilisateurs de se faire passer directement pour un autre utilisateur. Ce scénario, bien que pris en charge, n’est pas recommandé dans un environnement de production.

1. Configurez un rôle pour l’usurpation d’identité :

   USE ROLE ACCOUNTADMIN;
   CREATE ROLE janes_role;
   GRANT ROLE janes_role to USER jane;
   GRANT IMPERSONATE ON USER jane TO ROLE janes_role;
   

   Copy

2. Créez une tâche en utilisant le nouveau rôle :

   USE ROLE janes_role;
   
   CREATE TASK janes_task
     SCHEDULE='60 M' AS SELECT 1;
   

   Copy

3. Attribuez le rôle à un autre utilisateur.

   Dans l’exemple suivant, l’utilisateur Jane accorde l’accès à l’utilisateur Billy :

   --Logged in as Jane or account admin
   GRANT ROLE janes_role to USER billy;
   

   Copy

4. L’autre utilisateur modifie la tâche.

   Dans l’exemple suivant, l’utilisateur Billy modifie la tâche :

   -- Logged in as billy
   USE ROLE janes_role;
   
   ALTER TASK janes_task
     SET EXECUTE AS USER jane;
   

   Copy

5. Examinez les journaux.

   La commande SHOW GRANTS TO ROLE montrerait que Jane a accordé le rôle à Billy. La vue QUERY_HISTORY afficherait alors que Billy a modifié la tâche. Les futures exécutions de tâches apparaîtront toujours comme étant exécutées par Jane.

   USE ROLE ACCOUNTADMIN;
   
   SHOW GRANTS TO ROLE janes_role;
   
   QUERY_HISTORY()
     WHERE QUERY_TEXT ILIKE '%janes_task%';
   

   Copy