Introduction aux tâches¶

Tâches sans serveur¶

Avec ce modèle, les tâches s’exécutent sur des ordinateurs gérés par Snowflake. Snowflake redimensionne automatiquement les ressources en fonction des exigences de chaque charge de travail. Snowflake détermine la taille idéale des ressources de calcul pour une exécution donnée sur la base d’une analyse dynamique des statistiques des exécutions les plus récentes de la même tâche.

Ce modèle est recommandé pour les tâches qui s’exécutent de manière régulière ou semi-régulière, telles que :

• Les tâches qui démarrent toujours à la même heure.

• Les tâches qui ne s’exécutent qu’à l’arrivée de nouvelles données. (Pour plus d’informations, voir Tâches déclenchées.)

Comment Snowflake estime les ressources de calcul sans serveur¶

Snowflake estime automatiquement les ressources de calcul nécessaires à la réalisation d’une tâche en fonction du cadre temporel cible et des performances des tâches précédentes.

Vous pouvez définir la période cible à l’aide de TARGET_COMPLETION_INTERVAL. Si cette valeur n’est pas définie, Snowflake redimensionne les ressources de calcul sans serveur pour terminer avant la prochaine heure d’exécution planifiée.

Une fois la tâche terminée, Snowflake estime les ressources de calcul nécessaires comme suit :

• Si les tâches se terminent trop rapidement (dans un délai plusieurs fois inférieur à la période cible), Snowflake réduit les ressources attribuées pour les exécutions suivantes de une taille d’entrepôt, jusqu’à atteindre la valeur SERVERLESS_TASK_MIN_STATEMENT_SIZE.

• Si les tâches s’achèvent trop lentement (dans un cadre temporel supérieur d’un facteur au cadre cible), Snowflake augmente les ressources lors des exécutions suivantes d’une taille d’entrepôt. Lorsque la valeur SERVERLESS_TASK_MAX_STATEMENT_SIZE est atteinte, les tâches se poursuivent (en dépassant éventuellement la période cible) jusqu’à ce qu’elles se terminent ou qu’un délai d’expiration soit écoulé.

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),),
    ),
)

CREATE TASK SCHEDULED_T2
  SCHEDULE='USING CRON 0 * * * * America/Los_Angeles'
  TARGET_COMPLETION_INTERVAL='120 MINUTE'
  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=Cron("0 * * * *", "America/Los_Angeles"),
        target_completion_interval=timedelta(minutes=120),
        serverless_task_max_statement_size="LARGE",
    ),
)

CREATE TASK SCHEDULED_T3
  SCHEDULE='USING CRON 0 0 * * * UTC'
  TARGET_COMPLETION_INTERVAL='180 M'
  SERVERLESS_TASK_MIN_STATEMENT_SIZE='MEDIUM'
  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_T3",
        definition="SELECT 1",
        schedule=Cron("0 0 * * *", "UTC"),
        target_completion_interval=timedelta(minutes=180),
        serverless_task_min_statement_size="MEDIUM",
        serverless_task_max_statement_size="LARGE",
    ),
)

CREATE TASK SCHEDULED_T4
  SCHEDULE='10 SECONDS'
  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_T4",
        definition="SELECT 1",
        schedule=timedelta(seconds=10),
        serverless_task_max_statement_size="LARGE",
    ),
)

Modèle d’entrepôt virtuel géré par l’utilisateur¶

Avec ce modèle, vous contrôlez totalement les ressources de calcul utilisées pour chaque charge de travail.

Ce modèle est recommandé lorsque vous souhaitez gérer manuellement des charges imprévisibles sur les ressources de calcul. Les entrepôts multiclusters avec suspension automatique et reprise automatique activées peuvent également vous aider à modérer votre consommation de crédit.

Recommandations pour la sélection d’un modèle de calcul¶

Le tableau suivant décrit divers facteurs qui peuvent vous aider à décider quand utiliser des tâches sans serveur plutôt que des tâches gérées par l’utilisateur :

La taille maximale d’une exécution de tâche sans serveur est équivalente à un entrepôt XXLARGE. Si la charge de travail d’une tâche nécessite un entrepôt plus grand, créez une tâche gérée par l’utilisateur avec un entrepôt de la taille requise.

Exécuter une tâche selon une planification fixe¶

Pour exécuter une tâche selon une planification fixe, définissez la planification lors de la création ou de la modification de cette tâche à l’aide de CREATE TASK ou de ALTER TASK, ou en modifiant la tâche dans Snowsight, à l’aide du paramètre SCHEDULE.

Snowflake garantit qu’une seule instance d’une tâche avec une planification est exécutée à un moment. Si une tâche est toujours en cours d’exécution lors de la prochaine heure d’exécution planifiée, cette heure planifiée est ignorée.

L’exemple suivant crée une tâche qui s’exécute toutes les 10 secondes :

CREATE TASK task_runs_every_10_seconds
  SCHEDULE='10 SECONDS'
  AS SELECT 1;

Pour définir une planification basée sur une heure ou un jour spécifiques, utilisez le paramètre SCHEDULE =”USING CRON. ..”.

L’exemple suivant crée une tâche qui s’exécute tous les dimanches à 3 heures du matin, en utilisant le fuseau horaire Americas/Los_Angeles.

CREATE TASK task_sunday_3_am_pacific_time_zone
  SCHEDULE='USING CRON 0 3 * * SUN America/Los_Angeles'
AS SELECT 1;

Pour plus d’informations, voir CREATETASK … SCHEDULE.

Exécutez une tâche chaque fois qu’un flux contient de nouvelles données¶

Utilisez Tâches déclenchées pour exécuter des tâches chaque fois qu’un flux déterminé contient de nouvelles données, comme dans les workflows ELT (extraire, charger, transformer). Il n’est donc pas nécessaire d’interroger fréquemment une source lorsque la disponibilité de nouvelles données est imprévisible. Il réduit également le temps de latence car les données sont traitées immédiatement. Exemple :

CREATE TASK triggered_task_stream
  WHEN SYSTEM$STREAM_HAS_DATA('orders_stream')
  AS
    INSERT INTO completed_promotions
    SELECT order_id, order_total, order_time, promotion_id
    FROM orders_stream;

Pour plus d’informations, voir Tâches déclenchées.

Exécution selon une planification, mais uniquement si un flux contient de nouvelles données¶

Vous pouvez combiner une tâche planifiée avec une tâche déclenchée. Par exemple, vous pouvez paramétrer une tâche pour qu’elle s’exécute toutes les heures, mais uniquement si le flux contient de nouvelles données. Exemple :

CREATE TASK triggered_task_stream
  SCHEDULE = '1 HOUR'
  WHEN SYSTEM$STREAM_HAS_DATA('orders_stream')
  AS SELECT 1;

Suspension automatique de tâches après des échecs d’exécution¶

Il est possible de suspendre automatiquement des tâches après un nombre spécifié d’exécutions consécutives qui échouent ou dont le délai est dépassé. Cette fonction peut réduire les coûts en suspendant les tâches qui consomment des crédits Snowflake, mais ne s’exécutent pas jusqu’à leur terme.

Définir le paramètre SUSPEND_TASK_AFTER_NUM_FAILURES = num sur une tâche Lorsque le paramètre est défini sur une valeur supérieure à 0, les tâches sont automatiquement suspendues après que le nombre spécifié d’exécutions consécutives de la tâche ait échoué ou ait expiré.

Ce paramètre peut être défini lors de la création d’une tâche à l’aide de CREATE TASK ou après à l’aide de ALTER TASK. Vous pouvez également modifier cette valeur dans Snowsight.

Le paramètre SUSPEND_TASK_AFTER_NUM_FAILURES peut également être défini au niveau du compte, de la base de données ou du schéma. Le paramètre s’applique à toutes les tâches contenues dans l’objet modifié. Notez que la définition explicite du paramètre à un niveau inférieur remplace la valeur de paramètre définie à un niveau supérieur.

Réessayer automatiquement les tâches qui ont échoué¶

Si des graphiques de tâches se terminent dans un statut FAILED, Snowflake peut automatiquement réessayer les graphiques de tâches. La répétition automatique de tâches est désactivée par défaut. Pour activer cette fonction, définissez TASK_AUTO_RETRY_ATTEMPTS sur une valeur supérieure à 0.

Les tâches qui utilisent les notifications d’erreur envoient des notifications pour chaque nouvelle tentative échouée. Pour plus d’informations, voir Configuration d’une tâche pour envoyer des notifications d’erreur.

Lorsque vous définissez la valeur du paramètre TASK_AUTO_RETRY_ATTEMPTS au niveau du compte, de la base de données ou du schéma, le changement est appliqué aux tâches contenues dans l’objet modifié lors de leur exécution planifiée suivante.

Exécuter une tâche manuellement¶

Après avoir défini une nouvelle tâche et ses paramètres à l’aide de CREATE TASK ou ALTER TASK, vous pouvez lancer une exécution unique de la tâche à l’aide de EXECUTE TASK. Cette commande est utile pour tester des tâches nouvelles ou modifiées.

Gestion des versions des exécutions de tâches¶

Lorsqu’une tâche autonome est reprise pour la première fois ou exécutée manuellement, une version initiale de la tâche est définie. La tâche autonome s’exécute en utilisant cette version. Après la suspension et la modification d’une tâche, une nouvelle version est définie lorsque la tâche autonome est reprise ou exécutée manuellement.

Lorsque la tâche est suspendue, toutes les futures exécutions planifiées de la tâche sont annulées ; cependant, les tâches en cours d’exécution continuent de s’exécuter en utilisant la version actuelle.

Par exemple, supposons que la tâche soit suspendue, mais qu’une exécution planifiée de cette tâche ait déjà commencé. Le propriétaire de la tâche modifie le code SQL appelé par la tâche alors que celle-ci est toujours en cours d’exécution. La tâche s’exécute et exécute le code SQL dans sa définition en utilisant la version de la tâche qui existait lorsque la tâche a commencé son exécution. Lorsque la tâche est reprise ou est exécutée manuellement, une nouvelle version de la tâche est définie. Cette nouvelle version inclut les modifications apportées à la tâche.

Pour récupérer l’historique des versions de tâches, interrogez la vue TASK_VERSIONS Account Usage (dans la base de données partagée SNOWFLAKE).

Délais d’expiration¶

Si l’exécution d’une tâche dépasse la durée planifiée ou l’intervalle d’achèvement cible, la tâche continue par défaut à s’exécuter jusqu’à ce qu’elle soit terminée, qu’elle expire ou qu’elle échoue.

Lorsque STATEMENT_TIMEOUT_IN_SECONDS et label-user_task_timeout_ms sont tous deux définis, le délai d’expiration est la plus petite valeur non nulle de ces deux paramètres.

Lorsque STATEMENT_QUEUED_TIMEOUT_IN_SECONDS et USER_TASK_TIMEOUT_MS sont tous deux définis, la valeur de USER_TASK_TIMEOUT_MS prévaut.

Pour plus d’informations sur les délais d’expiration relatifs aux graphiques de tâches, voir Délais d’expiration du graphique de tâches.

Considérations¶

• Pour les tâches sans serveur, Snowflake dimensionne automatiquement les ressources pour s’assurer que les tâches se terminent dans un intervalle d’achèvement cible, y compris le temps de file d’attente.

• Pour les tâches gérées par l’utilisateur, des périodes d’attente plus longues sont courantes lorsque les tâches sont planifiées pour être exécutées dans un entrepôt partagé ou occupé.

Privilèges de contrôle d’accès¶

Créer des rôles personnalisés pour gérer les autorisations de tâches¶

Avec les rôles personnalisés, vous pouvez facilement gérer les autorisations accordées à chaque compte ou rôle dans Snowflake. Pour modifier les autorisations de tous les comptes ou rôles utilisant le rôle personnalisé, mettez ce dernier à jour. Vous pouvez également révoquer les autorisations en supprimant le rôle personnalisé.

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')
)

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"
)

USE ROLE securityadmin;

CREATE ROLE taskadmin;

from snowflake.core.role import Role

root.session.use_role("securityadmin")

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

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"
)

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'))

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é.

Exécution des tâches de service système¶

Snowflake exécute des tâches avec les privilèges du propriétaire, mais les tâches exécutées ne sont pas associées à un utilisateur. Au lieu de cela, chaque exécution est effectuée par un service système. Les tâches sont découplées d’utilisateurs spécifiques pour éviter les complications pouvant survenir lorsque des utilisateurs sont détruits, verrouillés en raison de problèmes d’authentification, ou lorsque des rôles sont supprimés.

Étant donné que les tâches exécutées sont découplées d’un utilisateur, l’historique des requêtes associées à ces tâches est associé au service système. En tant que tel, il n’existe aucun identifiants de connexion utilisateur pour ce service et aucune personne ne peut assumer son identité. L’activité pour le service système est limitée à votre compte. Les mêmes protections de chiffrement et autres protocoles de sécurité sont intégrés à ce service comme c’est le cas pour d’autres opérations.