Guida introduttiva: Eseguire attività pianificate con Funzioni di Azure

In questo articolo si usa l'interfaccia della riga di comando per sviluppatori di Azure (azd) per creare una funzione trigger timer per eseguire un'attività pianificata in Funzioni di Azure. Dopo aver verificato il codice in locale, distribuisci la nuova app per le funzioni serverless che hai creato ed eseguito nel piano Flex Consumption di Azure Functions.

L'origine del progetto usa azd per creare l'app per le funzioni e le risorse correlate e per distribuire il codice in Azure. Questa distribuzione segue le procedure consigliate correnti per le distribuzioni di Funzioni di Azure sicure e scalabili.

Per impostazione predefinita, il piano Flex Consumption segue un modello di fatturazione con pagamento in base al consumo, il che significa che è possibile completare questo articolo e sostenere solo un costo ridotto di pochi centesimi di USD o inferiore nell'account Azure.

Importante

Mentre l'esecuzione delle attività pianificate è supportata per tutti i linguaggi, questo scenario rapido d'inizio include attualmente solo esempi per C#, Python e TypeScript. Per completare questa guida introduttiva, selezionare una di queste lingue supportate nella parte superiore dell'articolo.

Prerequisiti

.NET 8 SDK

Node.js 22 o versione successiva

Python 3.11 o versione successiva
Emulatore di archiviazione di Azurite

CLI per sviluppatori di Azure
Strumenti di base di Funzioni di Azure
Un account Azure con una sottoscrizione attiva. Creare un account gratuito.

Inizializzare il progetto

Usare il azd init comando per creare un progetto di codice di Funzioni di Azure locale da un modello.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-dotnet-azd-timer -e scheduled-dotnet
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Il nome dell'ambiente viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per passare alla cartella dell'app:
```
cd src
```

Creare un file denominato local.settings.json nella cartella src che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-typescript-azd-timer -e scheduled-ts
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Il nome dell'ambiente viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella src che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-python-azd-timer -e scheduled-py
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azdl'ambiente mantiene un contesto di distribuzione univoco per l'app ed è possibile definire più di uno. Il nome dell'ambiente viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella src che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Creare e attivare un ambiente virtuale

Nella cartella principale, eseguire questi comandi per creare e attivare un ambiente virtuale denominato .venv:

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

Se Python non installa il pacchetto venv nella distribuzione Linux, eseguire il comando seguente:

sudo apt-get install python3-venv

py -m venv .venv
source .venv/scripts/activate

py -m venv .venv
.venv\scripts\activate

Eseguire l'ambiente locale

Eseguire questo comando dalla cartella dell'app in un terminale o nel prompt dei comandi:
```
func start
```

Eseguire questo comando dalla cartella dell'app in un terminale o nel prompt dei comandi:
```
npm install
npm start  
```

Quando l'host di Funzioni viene avviato nella cartella del progetto locale, scrive informazioni sulla funzione attivata dal timer nell'output del terminale. Verrà visualizzata l'esecuzione della funzione attivata dal timer in base alla pianificazione definita nel codice.

La pianificazione predefinita è */30 * * * * *, che viene eseguita ogni 30 secondi.
Al termine, premere CTRL+C nella finestra del terminale per arrestare il processo host func.exe.

Eseguire deactivate per arrestare l'ambiente virtuale.

Esaminare il codice (facoltativo)

È possibile esaminare il codice che definisce la funzione di trigger del timer:

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!");
            }
        }
    }
}

È possibile esaminare il progetto di modello completo qui.

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
});

È possibile esaminare il progetto di modello completo qui.

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

È possibile esaminare il progetto di modello completo qui.

Dopo aver verificato la funzione in locale, è possibile pubblicarla in Azure.

Distribuzione su Azure

Questo progetto è configurato per l'uso del comando azd up al fine di distribuire il codice in una nuova app per le funzioni in un piano a consumo flessibile in Azure.

Suggerimento

Questo progetto include un set di file Bicep che azd usa per creare una distribuzione sicura in un piano a consumo Flex che segue le procedure consigliate.

Eseguire questo comando affinché azd possa creare le risorse di Azure necessarie in Azure e distribuire il progetto di codice nella nuova app per le funzioni:
```
azd up
```
La cartella radice contiene il file di definizione azure.yaml richiesto da azd.

Se non è già stato eseguito l'accesso, viene chiesto di eseguire l'autenticazione con l'account Azure.

Quando richiesto, specificare questi parametri di distribuzione obbligatori:

Parametro	Description
Sottoscrizione di Azure	Sottoscrizione in cui vengono create le risorse.
Località di Azure	Area di Azure in cui creare il gruppo di risorse che contiene le nuove risorse di Azure. Vengono visualizzate solo le aree che attualmente supportano il piano a consumo Flex.

Il comando azd up usa la risposta a queste richieste con i file di configurazione Bicep per completare queste attività di distribuzione:

Creare e configurare queste risorse di Azure necessarie (equivalenti a azd provision):
- Piano a consumo Flex e app per le funzioni
- Archiviazione di Azure (richiesta) e Application Insights (scelta consigliata)
- Criteri di accesso e ruoli per l'account
- Connessioni da servizio a servizio che usano identità gestite (anziché stringhe di connessione archiviate)
- Rete virtuale per eseguire in modo sicuro sia l'app per le funzioni che le altre risorse di Azure
Creare un pacchetto e distribuire il codice nel contenitore di distribuzione (equivalente a azd deploy). L'app viene quindi avviata ed eseguita nel pacchetto distribuito.

Al termine del comando, vengono visualizzati i collegamenti alle risorse create.

Verificare la distribuzione

Dopo il completamento della distribuzione, la funzione trigger del timer viene avviata automaticamente in Azure in base alla relativa pianificazione.

Nel portale di Azure passare alla nuova app per le funzioni.
Selezionare Log stream (Flusso di log ) dal menu a sinistra per monitorare le esecuzioni delle funzioni in tempo reale.
Dovrebbero essere visualizzate le voci di log che mostrano la funzione di trigger del timer in esecuzione secondo la pianificazione.

Ridistribuire il codice

Eseguire il comando azd up quante volte è necessario per effettuare il provisioning delle risorse di Azure e distribuire gli aggiornamenti del codice nell'app per le funzioni.

Annotazioni

I file di codice distribuiti vengono sempre sovrascritti dal pacchetto di distribuzione più recente.

Le risposte iniziali alle richieste di azd e a tutte le variabili di ambiente generate da azd, vengono archiviate localmente nell'ambiente denominato. Usare il comando azd env get-values per esaminare tutte le variabili nell'ambiente usato durante la creazione di risorse di Azure.

Pulire le risorse

Al termine dell'uso dell'app per le funzioni e delle risorse correlate, usare questo comando per eliminare l'app per le funzioni e le relative risorse da Azure ed evitare di sostenere ulteriori costi:

azd down --no-prompt

Annotazioni

L'opzione --no-prompt indica a azd di eliminare il gruppo di risorse senza conferma.

Questo comando non influisce sul progetto di codice locale.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-12-01

Condividi tramite

Guida introduttiva: Eseguire attività pianificate con Funzioni di Azure

Prerequisiti

Inizializzare il progetto

Creare e attivare un ambiente virtuale

Eseguire l'ambiente locale

Esaminare il codice (facoltativo)

Distribuzione su Azure

Verificare la distribuzione

Ridistribuire il codice

Pulire le risorse

Articoli correlati

Commenti e suggerimenti

Risorse aggiuntive