Guida introduttiva: Creare un flusso di lavoro serverless usando Durable Functions

In questa guida introduttiva si usano gli strumenti da riga di comando per sviluppatori di Azure per creare un flusso di lavoro serverless che orchestra più attività in esecuzione in parallelo. Crei risorse in Azure, verifichi il codice localmente e quindi lo distribuisci in una nuova app per funzioni serverless in esecuzione in un piano Flex Consumption di Funzioni di Azure.

Il progetto usa l'interfaccia della riga di comando per sviluppatori di Azure (azd) per semplificare la distribuzione del codice in Azure. Questa distribuzione segue le procedure consigliate correnti per distribuzioni di Funzioni di Azure sicure e scalabili. Questa guida introduttiva illustra il modello fan-out/fan-in in Funzioni durature, un'estensione che orchestra flussi di lavoro a stati con esecuzione durevole. L'esempio utilizza il Durable Task Scheduler, un backend completamente gestito per Durable Functions che sostituisce il backend di Archiviazione di Azure. L'esempio recupera i titoli degli articoli in parallelo: l'orchestrazione si espande su più attività in esecuzione concorrente, quindi si riunisce per aggregare i risultati.

Per impostazione predefinita, il piano Flex Consumption segue un modello di fatturazione con pagamento in base al consumo, il che significa che il completamento di questa guida introduttiva comporta un costo ridotto di pochi centesimi di USD o inferiore nell'account Azure.

Prerequisiti

Inizializzare il progetto

Usare il comando azd init per creare un progetto di codice Durable Functions locale da un modello.

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-dotnet-azd -e dfquickstart-dotnet

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Cambia nella directory del progetto e poi naviga nella cartella dell'app fanoutfanin :

    cd durable-functions-quickstart-dotnet-azd/fanoutfanin

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-python-azd -e dfquickstart-python

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Cambia nella directory del progetto e poi naviga nella cartella dell'app src :

    cd durable-functions-quickstart-python-azd/src

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-typescript-azd -e dfquickstart-typescript

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Cambia nella directory del progetto e poi naviga nella cartella dell'app src :

    cd durable-functions-quickstart-typescript-azd/src

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-java-azd -e dfquickstart-java

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Spostarsi nella directory del progetto:

    cd durable-functions-quickstart-java-azd

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-javascript-azd -e dfquickstart-javascript

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Cambia nella directory del progetto e poi naviga nella cartella dell'app src :

    cd durable-functions-quickstart-javascript-azd/src

  1. Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:

    azd init --template durable-functions-quickstart-powershell-azd -e dfquickstart-powershell

    Questo comando esegue il pull dei file di progetto dal repository template e inizializza il progetto in una nuova cartella. 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.

  2. Cambia nella directory del progetto e poi naviga nella cartella dell'app src :

    cd durable-functions-quickstart-powershell-azd/src

Effettuare il provisioning delle risorse di Azure

Questo progetto utilizza il azd provision comando per creare le risorse Azure necessarie, inclusa una nuova app di funzioni in un piano Flex Consumption, un Task Scheduler Durable e un task hub.

Tip

Il progetto include un set di file Bicep (nella cartella infra) che azd utilizza per creare una distribuzione sicura in un piano di consumo Flex che segue le migliori pratiche.

  1. Torna alla cartella del progetto root (la cartella che contiene il azure.yaml file):

    cd ..
  1. Assicurati di essere ancora nella cartella root project (quella che contiene il azure.yaml file).

  1. Esegui questo comando per autenticarti con il tuo account Azure:

    azd auth login

  2. Esegui questo comando dalla cartella root del progetto per creare azd le risorse Azure richieste:

    azd provision

    La cartella radice contiene il file di definizione azure.yaml richiesto da azd.

  3. Quando richiesto, specificare questi parametri di distribuzione obbligatori:

    Parametro Description
    Sottoscrizione di Azure Sottoscrizione in cui vengono create le risorse. Se il tuo account ha più di un inquilino, devi prima scegliere il tuo inquilino.
    Area geografica di Azure Area di Azure in cui creare il gruppo di risorse contenente le nuove risorse di Azure. Vengono visualizzate solo le aree che attualmente supportano il piano Flex Consumption.
    vnetEnabled Se eseguire o meno la distribuzione in una rete virtuale. Per questo avvio rapido, seleziona falso.

    Il azd provision comando utilizza le tue risposte a questi prompt con i file di configurazione Bicep per creare e configurare queste risorse Azure necessarie:

    • Piano Consumo Flessibile e app per le funzioni
    • Archiviazione di Azure (obbligatorio) e Application Insights (scelta consigliata)
    • Pianificatore di attività durevole e hub attività
    • Criteri di accesso e ruoli per l'account
    • Connessioni da servizio a servizio che usano identità gestite (anziché stringhe di connessione archiviate)

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

    Il provisioning esegue anche uno script post-provision che genera il file local.settings.json nella cartella dell’app. Questo file contiene le impostazioni di connessione per l'endpoint Durable Task Scheduler distribuito, di cui hai bisogno per eseguire il progetto localmente.

Avvia Azurite

Per eseguire il progetto localmente, il runtime Functions necessita di un emulatore di storage locale. L'impostazione "AzureWebJobsStorage": "UseDevelopmentStorage=true" nel file local.settings.json indica all'runtime di utilizzare Azurite a questo scopo.

In una nuova finestra terminale, esegui questo comando per avviare Azurite:

azurite --skipApiVersionCheck --location ~/azurite-data

Mantieni Azurite attivo in questa finestra terminale mentre fai i test localmente.

Eseguire l'ambiente locale

  1. Nel terminale originale, vai alla cartella fanoutfanin app e avvia l'host di Functions:

    cd fanoutfanin
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint che avvia l'orchestrazione:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. Nel tuo terminale originale, vai nella src cartella app, crea e attiva un ambiente virtuale, installa le dipendenze e avvia l'host delle Funzioni:

    cd src

    Il modo in cui crei e attivi il tuo ambiente virtuale (chiamato .venv) dipende dal tuo terminale:

    python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint di avvio HTTP:

    http://localhost:7071/api/orchestrators/fetch_orchestration

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. Nel tuo terminale originale, vai nella cartella dell'app src , installa le dipendenze, costruisci il progetto e avvia l'host delle Funzioni:

    cd src
npm install
npm run build
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint di avvio HTTP:

    http://localhost:7071/api/orchestrators/fetchOrchestration

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. Nel tuo terminale originale, compila il progetto e poi avvia l'host Functions dalla cartella di output build:

    mvn clean package
cd target/azure-functions/durable-functions-quickstart
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint che avvia l'orchestrazione:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. Nel tuo terminale originale, vai nella src cartella app, installa le dipendenze e avvia l'host delle funzioni:

    cd src
npm install
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint che avvia l'orchestrazione:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. Nel terminale originale, vai alla cartella src app e avvia l'host di Functions:

    cd src
func start

    Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL locali delle funzioni attivate da HTTP nell'output del terminale.

    Note

    Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, non è necessaria una chiave di accesso per chiamare la funzione.

  2. Nel browser effettuare una richiesta GET all'endpoint che avvia l'orchestrazione:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Questa richiesta avvia una nuova istanza di orchestrazione. L'orchestrazione si ramifica in diverse attività per ottenere in parallelo i titoli degli articoli di Microsoft Learn. Al termine delle attività, l'orchestrazione si riconverge e i titoli vengono restituiti come stringa formattata.

  1. L'endpoint HTTP restituisce una risposta JSON con diversi URL. L'endpoint statusQueryGetUri fornisce lo stato di orchestrazione.

  2. Copiare il statusQueryGetUri valore e incollarlo nel browser o nello strumento di test HTTP per controllare lo stato dell'orchestrazione. Al termine dell'orchestrazione, nella risposta vengono visualizzati i titoli degli articoli recuperati.

  3. Al termine, premere CTRL+C nella finestra del terminale per arrestare il processo host func.

  1. Eseguire deactivate per arrestare l'ambiente virtuale.

Esaminare il codice (facoltativo)

È possibile esaminare il codice che implementa il modello fan-out/fan-in:

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga await Task.WhenAll(parallelTasks); attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

[Function(nameof(FetchOrchestration))]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    ILogger logger = context.CreateReplaySafeLogger(nameof(FetchOrchestration));
    logger.LogInformation("Fetching data.");
    var parallelTasks = new List<Task<string>>();
    
    // List of URLs to fetch titles from
    var urls = new List<string>
    {
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    };

    // Run fetching tasks in parallel
    foreach (var url in urls)
    {
        Task<string> task = context.CallActivityAsync<string>(nameof(FetchTitleAsync), url);
        parallelTasks.Add(task);
    }
    
    // Wait for all the parallel tasks to complete before continuing
    await Task.WhenAll(parallelTasks);
   
    // Return fetched titles as a formatted string
    return string.Join("; ", parallelTasks.Select(t => t.Result));
}

È possibile esaminare il progetto modello completo here.

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga yield context.task_all(tasks) attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

    # List of URLs to fetch titles from
    urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ]
    
    # Run fetching tasks in parallel
    tasks = []
    for url in urls:
        task = context.call_activity("fetch_title", url)
        tasks.append(task)
    
    # Wait for all the parallel tasks to complete before continuing
    results = yield context.task_all(tasks)
    
    # Return fetched titles as a formatted string
    return "; ".join(results)


@myApp.activity_trigger(input_name="url")
async def fetch_title(url: str):
    """Activity function that fetches the title from a URL."""
    logger = logging.getLogger("FetchTitle")
    logger.info(f"Fetching from url {url}.")
    
    try:
        async with ClientSession() as session:

È possibile esaminare il progetto modello completo here.

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga yield context.df.Task.all(parallelTasks) attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

    const urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ];

    // Run fetching tasks in parallel
    const parallelTasks = [];
    for (const url of urls) {
        const task = context.df.callActivity(fetchTitleActivityName, url);
        parallelTasks.push(task);
    }

    // Wait for all the parallel tasks to complete before continuing
    const results: string[] = yield context.df.Task.all(parallelTasks);

    // Return fetched titles as a formatted string
    return results.join("; ");
};
df.app.orchestration("fetchOrchestration", fetchOrchestration);

const fetchTitleAsync: ActivityHandler = async function (
    url: string,
    context: InvocationContext

È possibile esaminare il progetto modello completo here.

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga ctx.allOf(parallelTasks).await() attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

@FunctionName("FetchOrchestration")
public String runOrchestrator(
        @DurableOrchestrationTrigger(name = "taskOrchestrationContext") TaskOrchestrationContext ctx) {

    List<String> urls = List.of(
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps"
    );

    // Fan out: run fetching tasks in parallel
    List<Task<String>> parallelTasks = urls.stream()
        .map(url -> ctx.callActivity("FetchTitle", url, String.class))
        .collect(Collectors.toList());

    // Fan in: wait for all parallel tasks to complete
    List<String> results = ctx.allOf(parallelTasks).await();

    // Return fetched titles as a formatted string
    return String.join("; ", results);
}

È possibile esaminare il progetto modello completo here.

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga yield context.df.Task.all(parallelTasks) attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

df.app.orchestration('fetchOrchestration', function* (context) {
    context.log("Fetching data.");

    const urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ];

    // Fan out: run fetching tasks in parallel
    const parallelTasks = urls.map(url => context.df.callActivity(activityName, url));

    // Fan in: wait for all parallel tasks to complete
    const results = yield context.df.Task.all(parallelTasks);

    // Return fetched titles as a formatted string
    return results.join("; ");
});

È possibile esaminare il progetto modello completo here.

Le attività di fetching dei titoli vengono monitorate usando un elenco di task dinamico. La riga Wait-ActivityFunction -Task $parallelTasks attende il completamento di tutte le attività chiamate, eseguite contemporaneamente. Al termine, tutti gli output vengono aggregati come stringa formattata.

param($Context)

$urls = @(
    "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
    "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
    "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
    "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps"
)

# Fan out: run fetching tasks in parallel
$parallelTasks = @()
foreach ($url in $urls) {
    $parallelTasks += Invoke-DurableActivity -FunctionName 'FetchTitle' -Input $url -NoWait
}

# Fan in: wait for all parallel tasks to complete
$results = Wait-ActivityFunction -Task $parallelTasks

# Return fetched titles as a formatted string
$output = $results -join "; "
$output

È possibile esaminare il progetto modello completo here.

Dopo aver verificato localmente le tue funzioni, è il momento di distribuirle su Azure.

Distribuzione su Azure

Esegui questo comando dalla cartella root project per distribuire il tuo progetto di codice sull'app funzione in Azure:

azd deploy

Il comando azd deploy impacchetta e distribuisce il codice nell'app per le funzioni creata durante il provisioning. Dopo il completamento del comando, l'app si avvia ed esegue nel pacchetto distribuito.

Richiamare la funzione in Azure

È ora possibile richiamare l'endpoint di orchestrazione in Azure effettuando una richiesta HTTP al relativo URL. Quando le funzioni vengono eseguite in Azure, viene applicata l'autorizzazione della chiave di accesso ed è necessario fornire una chiave di accesso alla funzione con la richiesta.

È possibile usare Core Tools per ottenere l'endpoint URL del trigger HTTP che avvia l'orchestrazione in Azure.

  1. Nel terminale locale o nel prompt dei comandi, eseguire questi comandi per ottenere i valori dell'endpoint URL:

    APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp list-functions $APP_NAME --show-keys

    Il comando azd env get-value ottiene il nome dell'app per le funzioni dall'ambiente locale. Quando si usa l'opzione --show-keys con func azure functionapp list-functions, il valore Invoke URL: restituito per ogni endpoint include le chiavi di accesso a livello di funzione necessarie.

  2. Usa un browser o uno strumento di test HTTP per fare una richiesta GET all'endpoint HTTP di avvio per avviare l'orchestrazione nella tua app di funzione in esecuzione su Azure.

Ridistribuire il codice

Esegui azd deploy tutte le volte che serve per distribuire gli aggiornamenti del codice nella tua app di funzione. Se devi aggiornare le risorse di Azure, riesegui.azd provision

Note

Il pacchetto di distribuzione più recente sovrascrive sempre i file di codice distribuiti.

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

Note

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

Questo comando non influisce sul progetto di codice locale.

Contenuti correlati

  • Last updated on