> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Automazioni
> Pianifica attività ricorrenti e attiva funzioni automaticamente in base a eventi del database o eventi webhook dei connettori
Stai visualizzando la documentazione per sviluppatori
Questa documentazione è per sviluppatori che lavorano con la piattaforma di sviluppo Base44. Per informazioni sulle automazioni nell'editor di app, consulta Creare automazioni per la tua app.
Le automazioni consentono alle [funzioni backend](/developers/backend/resources/backend-functions/overview) di essere eseguite automaticamente in base a una pianificazione, in risposta a eventi del database o quando un'integrazione connessa invia un evento webhook. Usa le automazioni per elaborare dati a intervalli regolari, gestire modifiche alle entità, reagire a eventi di servizi esterni o eseguire attività una tantum in momenti specifici.
Ogni funzione backend può avere più automazioni associate, configurate nel file `function.jsonc` della funzione. Se hai solo un file `entry.ts` o `entry.js`, dovrai aggiungere questo file di configurazione per usare le automazioni. Le automazioni vengono [distribuite atomicamente con il codice della funzione](#deploy-automations) quando esegui [`deploy`](/developers/references/cli/commands/deploy) o [`functions deploy`](/developers/references/cli/commands/functions-deploy).
## Tipi di automazione
Base44 supporta 4 tipi di automazioni:
* **[Automazioni pianificate con cron](#cron)**: usa espressioni cron per un controllo preciso della pianificazione.
* **[Automazioni pianificate con pianificazioni semplici](#simple-schedule)**: configura attività ricorrenti per intervallo senza espressioni cron.
* **[Automazioni per eventi delle entità](#entity-events)**: attiva funzioni quando i record del database vengono creati, aggiornati o eliminati.
* **[Automazioni connettore](#connector-automations)**: rispondi in tempo reale agli eventi dei servizi connessi, come una nuova email in Gmail o una modifica di file in Google Drive.
## Campi comuni
### Campi comuni per tutte le automazioni
Tutti i tipi di automazione condividono i seguenti campi:
| Campo | Tipo | Richiesto | Descrizione |
| --------------- | --------- | --------- | ---------------------------------------------------------------------------------------------------------------- |
| `type` | `string` | Sì | Il tipo di automazione. Valori possibili: `"scheduled"`, `"entity"` o `"connector"`. |
| `name` | `string` | Sì | Identificatore univoco per l'automazione. |
| `description` | `string` | No | Descrizione leggibile. |
| `function_args` | `object` | No | Argomenti passati alla funzione quando viene attivata. Consulta [Argomenti della funzione](#function-arguments). |
| `is_active` | `boolean` | No | Se l'automazione è abilitata. Valore predefinito `true`. |
### Campi comuni per le automazioni pianificate
Sia le automazioni pianificate cron sia quelle semplici condividono questi campi aggiuntivi:
| Campo | Tipo | Richiesto | Descrizione |
| ------------------ | -------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `schedule_mode` | `string` | Sì | Se la pianificazione si ripete. Valori possibili: `"recurring"` o `"one-time"`. |
| `schedule_type` | `string` | Sì | Metodo di pianificazione da usare. Valori possibili: `"cron"` o `"simple"`. |
| `ends_type` | `string` | No | Quando la pianificazione ricorrente deve fermarsi. Valori possibili: `"never"`, `"on"` o `"after"`. Valore predefinito `"never"`. |
| `ends_on_date` | `string` | Condizionale | Data in cui termina la pianificazione ricorrente, inclusiva, in UTC. Richiesto quando `ends_type` è `"on"`. Formato: `YYYY-MM-DDTHH:MM:SSZ`. Ad esempio, `"2026-12-31T23:59:59Z"`. |
| `ends_after_count` | `number` | Condizionale | Numero di esecuzioni dopo il quale la pianificazione ricorrente si ferma. Richiesto quando `ends_type` è `"after"`. |
## Configurazione dell'automazione
Configura le automazioni nel tuo file `function.jsonc` usando uno degli approcci seguenti. Tutte le automazioni usano i [campi comuni per tutte le automazioni](#common-fields-for-all-automations) elencati sopra, più i campi specifici di ciascun tipo.
### Cron
Usa i [campi comuni per tutte le automazioni](#common-fields-for-all-automations) e i [campi comuni per le automazioni pianificate](#common-fields-for-scheduled-automations) insieme ai campi specifici cron elencati qui.
Imposta `type` su `"scheduled"` e `schedule_type` su `"cron"` per usare espressioni cron con un controllo preciso della pianificazione.
Le automazioni cron usano la sintassi standard a 5 campi: `minute hour day-of-month month day-of-week`. Consulta [crontab.guru](https://crontab.guru/) per un editor interattivo di espressioni cron e un riferimento della sintassi.
| Campo | Tipo | Richiesto | Descrizione |
| ----------------- | -------- | --------- | --------------------------- |
| `cron_expression` | `string` | Sì | Espressione cron a 5 campi. |
#### Esempio cron
Questo esempio esegue una funzione ogni giorno a mezzanotte UTC:
```jsonc theme={null}
{
"name": "sendDailyReport",
"entry": "entry.ts",
"automations": [
{
"type": "scheduled",
"name": "daily_midnight_report",
"description": "Runs every day at midnight UTC",
"function_args": { "mode": "full_sync" },
"is_active": true,
"schedule_mode": "recurring",
"schedule_type": "cron",
"cron_expression": "0 0 * * ?"
}
]
}
```
### Pianificazione semplice
Usa i [campi comuni per tutte le automazioni](#common-fields-for-all-automations) e i [campi comuni per le automazioni pianificate](#common-fields-for-scheduled-automations) insieme ai campi di pianificazione semplice elencati qui.
Imposta `type` su `"scheduled"` e `schedule_type` su `"simple"` per esigenze di pianificazione più immediate.
Configura attività ricorrenti per intervallo come minuti, ore, giorni, settimane o mesi senza scrivere espressioni cron.
| Campo | Tipo | Richiesto | Descrizione |
| ------------------------ | ---------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `one_time_date` | `string` | Condizionale | Data e ora in cui l'automazione viene eseguita una sola volta, in UTC. Richiesto quando `schedule_mode` è `"one-time"`. Formato: `YYYY-MM-DDTHH:MM:SSZ`. Ad esempio, `"2026-02-15T10:00:00Z"`. |
| `repeat_unit` | `string` | Condizionale | Unità di tempo per le automazioni ricorrenti. Richiesto quando `schedule_mode` è `"recurring"`. Valori possibili: `"minutes"`, `"hours"`, `"days"`, `"weeks"` o `"months"`. |
| `repeat_interval` | `number` | Condizionale | Intervallo tra le esecuzioni. Richiesto quando `repeat_unit` è `"minutes"`, `"hours"` o `"days"`. |
| `start_time` | `string` | Condizionale | Ora del giorno in cui viene eseguita l'automazione, in UTC. Richiesto quando `repeat_unit` è `"days"`, `"weeks"` o `"months"`. Formato: `HH:MM`. |
| `repeat_on_days` | `number[]` | Condizionale | Giorni della settimana in cui viene eseguita l'automazione. Richiesto quando `repeat_unit` è `"weeks"`. Array di numeri dei giorni della settimana, dove `0` è domenica e `6` è sabato. |
| `repeat_on_day_of_month` | `number` | Condizionale | Giorno del mese in cui viene eseguita l'automazione. Richiesto quando `repeat_unit` è `"months"`. Valori validi: `1`-`31`. |
#### Esempi di pianificazione semplice
I seguenti esempi mostrano diversi modi per pianificare automazioni con pianificazioni semplici:
```jsonc Every 30 minutes theme={null}
{
"type": "scheduled",
"name": "every_30_minutes",
"description": "Runs every 30 minutes.",
"is_active": true,
"schedule_mode": "recurring",
"schedule_type": "simple",
"repeat_unit": "minutes",
"repeat_interval": 30
}
```
```jsonc Weekdays at 9am theme={null}
{
"type": "scheduled",
"name": "weekday_morning_report",
"description": "Runs at 9 AM Monday through Friday.",
"is_active": true,
"schedule_mode": "recurring",
"schedule_type": "simple",
"repeat_unit": "weeks",
"repeat_interval": 1,
"start_time": "09:00",
"repeat_on_days": [1, 2, 3, 4, 5],
"ends_type": "after",
"ends_after_count": 52
}
```
```jsonc One-time execution theme={null}
{
"type": "scheduled",
"name": "one_time_cleanup",
"description": "Runs once at a specific date and time.",
"function_args": { "cleanup": true },
"is_active": true,
"schedule_mode": "one-time",
"schedule_type": "simple",
"one_time_date": "2026-02-15T10:00:00Z"
}
```
### Eventi delle entità
Usa i [campi comuni per tutte le automazioni](#common-fields-for-all-automations) insieme ai campi degli eventi delle entità elencati qui.
Imposta `type` su `"entity"` per attivare funzioni automaticamente quando i record del database vengono creati, aggiornati o eliminati.
Le automazioni delle entità possono ascoltare 1 o più tipi di eventi su una specifica entità.
| Campo | Tipo | Richiesto | Descrizione |
| ------------- | ---------- | --------- | ----------------------------------------------------------------------------------------------------------- |
| `entity_name` | `string` | Sì | Nome dell'entità da monitorare. |
| `event_types` | `string[]` | Sì | Eventi del database da ascoltare. Valori possibili: `"create"`, `"update"`, `"delete"`. Almeno 1 richiesto. |
#### Esempi di eventi delle entità
I seguenti esempi mostrano come attivare funzioni in base agli eventi delle entità:
```jsonc All order events theme={null}
{
"name": "processOrders",
"entry": "entry.ts",
"automations": [
{
"type": "entity",
"name": "on_order_changes",
"description": "Triggered on order create, update, or delete.",
"function_args": { "notify_slack": true },
"is_active": true,
"entity_name": "orders",
"event_types": ["create", "update", "delete"]
}
]
}
```
```jsonc New records only theme={null}
{
"type": "entity",
"name": "on_customer_create",
"description": "Triggered when a new customer is created.",
"is_active": true,
"entity_name": "customers",
"event_types": ["create"]
}
```
### Automazioni connettore
Usa i [campi comuni per tutte le automazioni](#common-fields-for-all-automations) insieme ai campi specifici del connettore elencati qui.
Imposta `type` su `"connector"` per attivare funzioni quando un'integrazione connessa invia un evento webhook. Usa queste per reagire in tempo reale all'attività di servizi esterni. Ad esempio, puoi analizzare una nuova email, sincronizzare una modifica del calendario o rispondere a un aggiornamento di file in Google Drive.
Puoi opzionalmente aggiungere [condizioni di trigger](#trigger-conditions) per filtrare gli eventi in modo che la tua funzione venga eseguita solo quando il payload corrisponde alle regole che definisci.
Quando un'automazione connettore si attiva, la tua funzione riceve un [payload webhook](#webhook-payload) strutturato che contiene il tipo di evento, i dettagli dell'integrazione e i dati grezzi dal servizio esterno.
Il connettore deve essere configurato nel tuo progetto e autorizzato prima della distribuzione. Consulta [Connettori condivisi](/developers/backend/resources/connectors/shared-connectors) per le istruzioni di configurazione.
| Campo | Tipo | Richiesto | Descrizione |
| -------------------- | ---------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `integration_type` | `string` | Sì | L'identificatore del tipo di connettore su cui ascoltare. Consulta [integrazioni supportate](#supported-integrations-and-events) per i valori accettati. |
| `events` | `string[]` | Sì | Uno o più nomi di eventi webhook a cui iscriversi. Consulta [integrazioni supportate](#supported-integrations-and-events) per gli eventi disponibili per ogni connettore. |
| `resource_id` | `string` | Condizionale | Limita l'automazione a una risorsa specifica. Il formato atteso dipende dal connettore. Consulta [Formati resource ID](#resource-id-formats) qui sotto. Richiesto per gli eventi Google Drive con ambito di file. Opzionale per altri connettori. |
| `trigger_conditions` | `object` | No | Regole che devono corrispondere all'evento in arrivo prima che la tua funzione venga eseguita. Se l'evento non corrisponde, l'esecuzione viene saltata. Consulta [Condizioni di trigger](#trigger-conditions) per il riferimento completo. |
#### Integrazioni ed eventi supportati
| Connettore | `integration_type` | Valore `events` | Descrizione |
| -------------------- | ------------------ | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Gmail | `gmail` | `mailbox` | Qualsiasi modifica alla casella di posta, inclusi nuovi messaggi, aggiornamenti di etichette e modifiche allo stato di lettura. |
| Google Calendar | `googlecalendar` | `events` | Qualsiasi modifica a un evento del calendario, incluse creazione, aggiornamento ed eliminazione. |
| Google Drive | `googledrive` | `changes` | Qualsiasi modifica nel drive, inclusi file aggiunti, modificati o eliminati. |
| Google Drive | `googledrive` | `file` | Qualsiasi modifica a un file specifico (richiede `resource_id`). |
| Google Drive | `googledrive` | `file.update` | Contenuto o proprietà del file modificati (richiede `resource_id`). |
| Google Drive | `googledrive` | `file.trash` | File spostato nel cestino (richiede `resource_id`). |
| Google Drive | `googledrive` | `file.untrash` | File ripristinato dal cestino (richiede `resource_id`). |
| Google Drive | `googledrive` | `file.delete` | File eliminato definitivamente (richiede `resource_id`). |
| Microsoft OneDrive | `one_drive` | `updated` | Qualsiasi modifica di file o cartella, incluse creazione, modifica ed eliminazione. |
| Microsoft Outlook | `outlook` | `created` | Vengono creati una nuova email, un evento del calendario o un contatto. |
| Microsoft Outlook | `outlook` | `updated` | Un'email, un evento del calendario o un contatto vengono aggiornati. |
| Microsoft Outlook | `outlook` | `deleted` | Un'email, un evento del calendario o un contatto vengono eliminati. |
| Microsoft SharePoint | `share_point` | `updated` | Quando un elemento di elenco o un documento viene creato, modificato o eliminato. |
| Microsoft Teams | `microsoft_teams` | `created` | Quando viene pubblicato un nuovo messaggio in chat. |
| Microsoft Teams | `microsoft_teams` | `updated` | Quando un messaggio in chat viene aggiornato. |
| Microsoft Teams | `microsoft_teams` | `deleted` | Quando un messaggio in chat viene eliminato. |
| Slack | `slack` | `message` | Quando viene pubblicato un messaggio in un canale. |
| Slack | `slack` | `message.im` | Quando viene pubblicato un messaggio diretto. |
| Slack | `slack` | `message.groups` | Quando viene pubblicato un messaggio in un canale privato. |
| Slack | `slack` | `message.channels` | Quando viene pubblicato un messaggio in un canale pubblico. |
| Slack | `slack` | `message.mpim` | Quando viene pubblicato un messaggio in una IM multi-party. |
| Slack | `slack` | `reaction_added` | Quando viene aggiunta una reazione a un messaggio. |
| Slack | `slack` | `reaction_removed` | Quando viene rimossa una reazione da un messaggio. |
| Slack | `slack` | `member_joined_channel` | Quando un utente entra in un canale. |
| Slack | `slack` | `member_left_channel` | Quando un utente lascia un canale. |
| Slack | `slack` | `file_shared` | Quando viene condiviso un file. |
| Slack Bot | `slackbot` | `app_mention` | Quando il bot viene menzionato con @. |
| Slack Bot | `slackbot` | `message.im` | Quando viene inviato un messaggio diretto al bot. |
| Slack Bot | `slackbot` | `message.mpim` | Quando viene inviato un messaggio in un DM di gruppo con il bot. |
| Slack Bot | `slackbot` | `message.channels` | Quando viene pubblicato un messaggio in un canale pubblico in cui è presente il bot. |
| Slack Bot | `slackbot` | `message.groups` | Quando viene pubblicato un messaggio in un canale privato in cui è presente il bot. |
| Wix | `wix` | `wix.forms.v4.submission_created` | È stata creata una submission del modulo su un sito Wix. |
| Wix | `wix` | `wix.contacts.v4.contact_created` | È stato creato un contatto in Wix CRM. |
| Wix | `wix` | `wix.contacts.v4.contact_updated` | Un contatto Wix CRM è stato aggiornato. |
| Wix | `wix` | `wix.contacts.v4.contact_deleted` | Un contatto Wix CRM è stato eliminato. |
| Wix | `wix` | `wix.ecom.v1.order_created` | È stato creato un ordine Wix eCommerce. |
| Wix | `wix` | `wix.ecom.v1.order_updated` | Un ordine Wix eCommerce è stato aggiornato. |
| Wix | `wix` | `wix.ecom.v1.order_canceled` | Un ordine Wix eCommerce è stato annullato. |
| Wix | `wix` | `wix.ecom.v1.checkout_created` | È stato creato un checkout Wix eCommerce. |
| Wix | `wix` | `wix.data.v2.data_item_created` | È stato creato un data item Wix CMS. |
| Wix | `wix` | `wix.data.v2.data_item_updated` | Un data item Wix CMS è stato aggiornato. |
| Wix | `wix` | `wix.data.v2.data_item_deleted` | Un data item Wix CMS è stato eliminato. |
L'evento `mailbox` di Gmail si attiva per qualsiasi modifica della casella di posta, non solo per nuovi messaggi. Per eseguire la tua funzione solo quando arrivano nuove email, aggiungi una condizione di trigger: `{ "field": "has_new_messages", "operator": "equals", "value": true }`.
Le automazioni dei connettori Slack (`slack`) e Slack Bot (`slackbot`) richiedono condizioni di trigger. La distribuzione fallirà se non sono impostate condizioni per queste automazioni connettore.
#### Formati resource ID
Il valore atteso per `resource_id` varia in base al connettore:
* **Google Drive:** l'ID del file. Richiesto per gli eventi con ambito di file (`file`, `file.update`, `file.trash`, `file.untrash`, `file.delete`).
* **Gmail:** un elenco separato da virgole di ID di etichette da monitorare. Valore predefinito `"INBOX"` se omesso.
* **Microsoft Teams:** `{teamId}/{channelId}` per monitorare un canale specifico, o `{chatId}` per monitorare una chat specifica.
* **SharePoint:** `{siteId}/{listId}` per monitorare un elenco specifico.
#### Condizioni di trigger
Usa `trigger_conditions` per filtrare gli eventi webhook in modo che la tua funzione venga eseguita solo quando il payload corrisponde alle regole che definisci. Se non sono impostate condizioni, la funzione viene eseguita per ogni evento in arrivo. Consulta [Esempi di automazioni connettore](#connector-automation-examples) per configurazioni complete.
Come combinare le condizioni. Valori possibili: `"and"` (tutti devono corrispondere), `"or"` (almeno uno deve corrispondere). Valore predefinito `"and"`.
Uno o più oggetti condizione o gruppi di condizioni annidati. Massimo 20 condizioni foglia e 5 livelli di annidamento.
Percorso separato da punti nel payload webhook. Ad esempio, `"status"` legge `payload.data.status` e `"sender.email"` legge `payload.data.sender.email`.
Come confrontare il valore del campo.
| Operatore | Descrizione |
| -------------- | ----------------------------------------------------------------------------------------------------- |
| `equals` | Il valore del campo corrisponde esattamente a `value`. |
| `not_equals` | Il valore del campo non corrisponde a `value`. |
| `contains` | Il valore del campo contiene `value` come sottostringa. |
| `not_contains` | Il valore del campo non contiene `value` come sottostringa. |
| `starts_with` | Il valore del campo inizia con `value`. |
| `ends_with` | Il valore del campo termina con `value`. |
| `gt` | Il valore del campo è maggiore di `value`. |
| `gte` | Il valore del campo è maggiore o uguale a `value`. |
| `lt` | Il valore del campo è minore di `value`. |
| `lte` | Il valore del campo è minore o uguale a `value`. |
| `in_list` | Il valore del campo è uno degli elementi in `value` (un array). |
| `not_in_list` | Il valore del campo non è uno degli elementi in `value` (un array). |
| `exists` | Il campo è presente e non nullo. Nessun `value` richiesto. |
| `not_exists` | Il campo è nullo o mancante. Nessun `value` richiesto. |
| `is_empty` | Il campo è nullo, una stringa vuota, un array vuoto o un oggetto vuoto. Nessun `value` richiesto. |
| `is_not_empty` | Il campo non è nullo, una stringa vuota, un array vuoto o un oggetto vuoto. Nessun `value` richiesto. |
Il valore con cui confrontare. Non richiesto per `exists`, `not_exists`, `is_empty` e `is_not_empty`.
#### Payload webhook
Quando un'automazione connettore attiva la tua funzione, il corpo della richiesta contiene un oggetto `payload` con la seguente struttura. Consulta [Esempi di automazioni connettore](#connector-automation-examples) per una funzione che legge il payload.
| Campo | Tipo | Descrizione |
| ----------------------------------- | --------- | -------------------------------------------------------------------------------------------------------- |
| `payload.automation.id` | `string` | ID dell'automazione che ha attivato questa esecuzione. |
| `payload.automation.name` | `string` | Nome dell'automazione. |
| `payload.automation.type` | `string` | Sempre `"connector"`. |
| `payload.event.type` | `string` | Il nome dell'evento webhook. Ad esempio, `"mailbox"`, `"events"` o `"changes"`. |
| `payload.event.integration_type` | `string` | Il tipo di connettore. Ad esempio, `"gmail"` o `"googlecalendar"`. |
| `payload.event.provider_identifier` | `string` | L'identificatore dell'account provider usato per l'instradamento. |
| `payload.data` | `object` | Il payload webhook grezzo dal servizio esterno. Impostato su `null` quando `payload_too_large` è `true`. |
| `payload.payload_too_large` | `boolean` | È `true` quando il payload webhook ha superato \~200 KB e `data` è `null`. |
#### Esempi di automazioni connettore
```jsonc Basic connector automation theme={null}
// Triggers the function whenever a new email arrives in Gmail.
{
"name": "processInboundEmails",
"entry": "entry.ts",
"automations": [
{
"type": "connector",
"name": "on_new_gmail",
"description": "Runs when a new email arrives in Gmail.",
"is_active": true,
"integration_type": "gmail",
"events": ["mailbox"]
}
]
}
```
```jsonc Single trigger condition theme={null}
// Triggers only when a Google Calendar event has status "cancelled".
{
"type": "connector",
"name": "on_event_cancelled",
"description": "Runs only when a Google Calendar event is cancelled.",
"is_active": true,
"integration_type": "googlecalendar",
"events": ["events"],
"trigger_conditions": {
"logic": "and",
"conditions": [
{ "field": "status", "operator": "equals", "value": "cancelled" }
]
}
}
```
```jsonc Nested trigger conditions theme={null}
// Triggers only for Gmail messages that are both in the inbox and unread.
{
"type": "connector",
"name": "on_unread_inbox_email",
"description": "Runs only for unread emails in the inbox.",
"is_active": true,
"integration_type": "gmail",
"events": ["mailbox"],
"trigger_conditions": {
"logic": "and",
"conditions": [
{ "field": "labelIds", "operator": "contains", "value": "INBOX" },
{ "field": "labelIds", "operator": "contains", "value": "UNREAD" }
]
}
}
```
```typescript Reading the payload theme={null}
// Reads the structured payload from the request body.
Deno.serve(async (req) => {
const body = await req.json();
const { payload } = body;
const eventType = payload.event.type;
const integration = payload.event.integration_type;
if (payload.payload_too_large) {
console.warn("Webhook payload was too large and was not included.");
return Response.json({ ok: false, reason: "payload_too_large" });
}
const data = payload.data;
// Your function logic
console.log(`Received ${eventType} event from ${integration}`, data);
return Response.json({ ok: true });
});
```
### Argomenti della funzione
Passa dati alla tua funzione quando viene attivata includendo il campo `function_args` nella configurazione della tua automazione. Questo è utile quando una funzione gestisce più automazioni con comportamenti diversi, come una funzione di sincronizzazione che viene eseguita in modo incrementale ogni 15 minuti ma esegue una sincronizzazione completa quotidianamente.
Accedi a questi argomenti nel codice della tua funzione tramite il corpo della richiesta.
#### Esempio di argomenti della funzione
Questo esempio mostra una funzione che gestisce sia la modalità di sincronizzazione incrementale sia quella completa in base alla configurazione dell'automazione:
```typescript Function code theme={null}
Deno.serve(async (req) => {
const body = await req.json();
const args = body.args ?? {};
// Use the arguments from automation config
const mode = args.mode ?? "incremental";
// Your function logic
});
```
```jsonc Automation config theme={null}
{
"name": "syncData",
"entry": "entry.ts",
"automations": [
{
"type": "scheduled",
"name": "incremental_sync",
"description": "Runs every 15 minutes with incremental mode.",
"function_args": { "mode": "incremental" },
"is_active": true,
"schedule_mode": "recurring",
"schedule_type": "simple",
"repeat_unit": "minutes",
"repeat_interval": 15
},
{
"type": "scheduled",
"name": "full_sync",
"description": "Runs daily at midnight with full sync mode.",
"function_args": { "mode": "full" },
"is_active": true,
"schedule_mode": "recurring",
"schedule_type": "cron",
"cron_expression": "0 0 * * ?"
}
]
}
```
## Distribuisci le automazioni
Distribuisci le funzioni backend con le loro automazioni usando il comando CLI [`functions deploy`](/developers/references/cli/commands/functions-deploy) o il comando unificato [`deploy`](/developers/references/cli/commands/deploy). Puoi distribuire funzioni specifiche per nome con `functions deploy `.
La distribuzione è atomica per funzione. Una funzione è considerata distribuita solo se sia la distribuzione Deno sia tutte le sue automazioni hanno successo. Se un'automazione non viene distribuita, l'intera distribuzione della funzione viene ripristinata.
Dopo la distribuzione, la CLI mostra lo stato per funzione: distribuita, invariata o errore.
## Gestire le automazioni nella dashboard
Qualsiasi modifica effettuata nella dashboard verrà sovrascritta la prossima volta che esegui [`functions deploy`](/developers/references/cli/commands/functions-deploy). Non esiste una sincronizzazione bidirezionale tra la dashboard e i tuoi file locali. Le automazioni definite nei tuoi file `function.jsonc` locali sono la fonte di verità.
Se vuoi apportare modifiche alle tue automazioni, aggiorna i tuoi file `function.jsonc` locali e ridistribuisci. Usa la dashboard per monitorare i log di esecuzione e attivare manualmente le automazioni quando necessario.
Visualizza e gestisci le tue automazioni nella dashboard Base44 nella scheda **Automations**. Dalla dashboard, puoi:
* Visualizzare log di esecuzione e cronologia
* Eseguire manualmente le automazioni per i test
* Monitorare lo stato dell'automazione
## Vedi anche
* [Funzioni backend](/developers/backend/resources/backend-functions/overview): scopri le funzioni backend
* [`functions deploy`](/developers/references/cli/commands/functions-deploy): distribuisci funzioni con automazioni
* [`deploy`](/developers/references/cli/commands/deploy): distribuisci tutte le risorse in una volta
* [`logs`](/developers/references/cli/commands/logs): visualizza i log delle funzioni
Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/).