Partager via

Démarrage rapide : Exécuter des tâches planifiées à l’aide d’Azure Functions

Dans cet article, vous utilisez Azure Developer CLI (azd) pour créer une fonction de déclencheur du minuteur pour exécuter une tâche planifiée dans Azure Functions. Après avoir vérifié le code localement, vous le déployez sur une nouvelle application de fonction serverless que vous créez en cours d’exécution dans un plan Flex Consumption dans Azure Functions.

La source du projet utilise azd pour créer l’application de fonction et les ressources associées et déployer votre code sur Azure. Ce déploiement suit les bonnes pratiques actuelles pour les déploiements Azure Functions sécurisés et scalables.

Par défaut, le plan Flex Consumption suit un modèle de facturation de paiement à l’utilisation , ce qui signifie que vous pouvez suivre cet article et que vous n’avez qu’un petit coût de quelques cents USD ou moins dans votre compte Azure.

Important

Bien que l’exécution de tâches planifiées soit prise en charge pour tous les langages, ce scénario de démarrage rapide ne contient actuellement que des exemples pour C#, Python et TypeScript. Pour suivre ce guide de démarrage rapide, sélectionnez l’une de ces langues prises en charge en haut de l’article.

Prerequisites

Initialiser le projet

Utilisez la azd init commande pour créer un projet de code Azure Functions local à partir d’un modèle.

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

    azd init --template functions-quickstart-dotnet-azd-timer -e scheduled-dotnet

    Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Exécutez cette commande pour accéder au dossier de l’application :

    cd src

  3. Créez un fichier nommé local.settings.json dans le src dossier qui contient ces données JSON :

    {
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
        "TIMER_SCHEDULE": "*/30 * * * * *"
    }
}

    Ce fichier est requis lors d’une exécution locale.

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

    azd init --template functions-quickstart-typescript-azd-timer -e scheduled-ts

    Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Créez un fichier nommé local.settings.json dans le src dossier qui contient ces données JSON :

    {
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node",
        "TIMER_SCHEDULE": "*/30 * * * * *"
    }
}

    Ce fichier est requis lors d’une exécution locale.

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

    azd init --template functions-quickstart-python-azd-timer -e scheduled-py

    Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Créez un fichier nommé local.settings.json dans le src dossier qui contient ces données JSON :

    {
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "python",
        "TIMER_SCHEDULE": "*/30 * * * * *"
    }
}

    Ce fichier est requis lors d’une exécution locale.

Créer et activer un environnement virtuel

Dans le dossier racine, exécutez ces commandes pour créer et activer un environnement virtuel nommé .venv :

python3 -m venv .venv
source .venv/bin/activate

Si Python n’installe pas le package venv sur votre distribution Linux, exécutez la commande suivante :

sudo apt-get install python3-venv

Exécuter dans votre environnement local

  1. Exécutez cette commande à partir du dossier de votre application dans un terminal ou à l’invite de commandes :

    func start

  1. Exécutez cette commande à partir du dossier de votre application dans un terminal ou à l’invite de commandes :

    npm install
npm start

  1. Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les informations sur votre fonction de déclencheur Timer dans la sortie du terminal. Vous devez voir votre fonction déclenchée par minuteur s’exécuter en fonction de la planification définie dans votre code.

    La planification par défaut est */30 * * * * *, qui s’exécute toutes les 30 secondes.

  2. Lorsque vous avez terminé, appuyez sur Ctrl + C dans la fenêtre du terminal pour arrêter le processus hôte func.exe.

  1. Exécutez deactivate pour arrêter l’environnement virtuel.

Examiner le code (facultatif)

Vous pouvez consulter le code qui définit la fonction de déclencheur du minuteur :

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Timer;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class timerFunction
    {
        private readonly ILogger _logger;

        public timerFunction(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<timerFunction>();
        }

        [Function("timerFunction")]
        public void Run(
            [TimerTrigger("%TIMER_SCHEDULE%", RunOnStartup = true)] TimerInfo myTimer,
            FunctionContext context
        )
        {
            _logger.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

            if (myTimer.IsPastDue)
            {
                _logger.LogWarning("The timer is running late!");
            }
        }
    }
}

Vous pouvez consulter le projet de modèle complet ici.

import { app, InvocationContext, Timer } from '@azure/functions';

export async function timerFunction(myTimer: Timer, context: InvocationContext): Promise<void> {
    context.log(`TypeScript Timer trigger function executed at: ${new Date().toISOString()}`);

    if (myTimer.isPastDue) {
        context.warn("The timer is running late!");
    }
}

app.timer('timerFunction', {
    schedule: '%TIMER_SCHEDULE%',
    runOnStartup: true,
    handler: timerFunction
});

Vous pouvez consulter le projet de modèle complet ici.

import datetime
import logging

import azure.functions as func

# Create the function app instance
app = func.FunctionApp()

@app.timer_trigger(schedule="%TIMER_SCHEDULE%", 
                   arg_name="mytimer", 
                   run_on_startup=True,
                   use_monitor=False) 
def timer_function(mytimer: func.TimerRequest) -> None:
    utc_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
    
    logging.info(f'Python timer trigger function executed at: {utc_timestamp}')
    
    if mytimer.past_due:
        logging.warning('The timer is running late!')

Vous pouvez consulter le projet de modèle complet ici.

Après avoir vérifié votre fonction localement, il est temps de le publier sur Azure.

Déployer sur Azure

Ce projet est configuré pour utiliser la azd up commande pour déployer votre code sur une nouvelle application de fonction dans un plan Flex Consumption dans Azure.

Conseil / Astuce

Ce projet comprend un ensemble de fichiers Bicep qu’utilise azd pour créer un déploiement sécurisé dans un plan Consommation flexible qui suit les bonnes pratiques.

  1. Exécutez cette commande pour qu’azd crée les ressources Azure requises dans Azure et déployer votre projet de code dans la nouvelle application de fonction :

    azd up

    Le dossier racine contient le fichier de définition azure.yaml exigé par azd.

    Si vous n’êtes pas déjà connecté, vous êtes invité à vous authentifier auprès de votre compte Azure.

  2. Lorsque vous y êtes invité, fournissez ces paramètres de déploiement requis :

    Paramètre Descriptif
    Abonnement Azure Abonnement dans lequel vos ressources sont créées.
    Emplacement Azure Région Azure dans laquelle créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules sont montrées les régions qui prennent actuellement en charge le plan Consommation flexible.

    La commande azd up utilise votre réponse à ces invites avec les fichiers de configuration Bicep pour effectuer ces tâches de déploiement :

    • Créez et configurez ces ressources Azure requises (équivalentes à azd provision) :

      • Plan Consommation flexible et application de fonction
      • Stockage Azure (obligatoire) et Application Insights (recommandé)
      • Stratégies d’accès et rôles pour votre compte
      • Connexions de service à service avec des identités managées (au lieu de chaînes de connexion stockées)
      • Réseau virtuel pour exécuter de façon sécurisée l’application de fonction et les autres ressources Azure

    • Empaquetez et déployez votre code sur le conteneur de déploiement (équivalent à azd deploy). L’application est ensuite démarrée et s’exécute dans le package déployé.

    Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées.

Vérifier le déploiement

Une fois le déploiement terminé, votre fonction de déclencheur Timer s’exécute automatiquement dans Azure selon sa planification.

  1. Dans le portail Azure, accédez à votre nouvelle application de fonction.

  2. Sélectionnez Flux de journal dans le menu de gauche pour surveiller vos exécutions de fonction en temps réel.

  3. Vous devriez voir les entrées du journal montrant que la fonction de déclencheur Timer s’exécute selon sa planification.

Redéployer votre code

Exécutez la azd up commande autant de fois que vous devez provisionner vos ressources Azure et déployer des mises à jour de code sur votre application de fonction.

Note

Les fichiers de code déployés sont toujours remplacés par le dernier package de déploiement.

Vos réponses initiales aux invites d’azd et toutes les variables d’environnement générées par azd sont stockées localement dans votre environnement nommé. Utilisez la commande azd env get-values pour passer en revue toutes les variables de votre environnement qui ont été utilisées lors de la création de ressources Azure.

Nettoyer les ressources

Lorsque vous avez terminé d’utiliser votre application de fonction et vos ressources associées, utilisez cette commande pour supprimer l’application de fonction et ses ressources associées d’Azure et éviter d’entraîner d’autres coûts :

azd down --no-prompt

Note

L’option --no-prompt indique à azd de supprimer votre groupe de ressources sans confirmation de votre part.

Cette commande n’affecte pas votre projet de code local.

  • Last updated on