Agenci w przepływach pracy

W tym samouczku pokazano, jak zintegrować agentów sztucznej inteligencji z przepływami pracy przy użyciu platformy Agent Framework. Dowiesz się, jak tworzyć przepływy pracy, które wykorzystują możliwości wyspecjalizowanych agentów sztucznej inteligencji do tworzenia zawartości, przeglądania i innych zadań współpracy.

Co będziesz budować

Utworzysz przepływ pracy, który:

• Używa usługi Azure Foundry Agent Service do tworzenia inteligentnych agentów
• Implementuje francuskiego agenta tłumaczenia, który tłumaczy dane wejściowe na język francuski
• Implementuje hiszpańskiego agenta tłumaczenia, który tłumaczy język francuski na hiszpański
• Implementuje angielskiego agenta tłumaczenia, który tłumaczy język hiszpański z powrotem na angielski
• Łączy agentów w sekwencyjnej ścieżce pracy.
• Przesyła strumieniowo aktualizacje w czasie rzeczywistym, gdy agenci przetwarzają żądania
• Demonstruje prawidłowe czyszczenie zasobów dla agentów usługi Azure Foundry

Omówione pojęcia

• Agenci w przepływach pracy
• Krawędzie bezpośrednie
• Konstruktor przepływu pracy

Wymagania wstępne

• Pakiet .NET 8.0 SDK lub nowszy
• Skonfigurowany punkt końcowy i model projektu usługi Azure Foundry
• Zainstalowany i uwierzytelniony interfejs wiersza polecenia platformy Azure(na potrzeby uwierzytelniania poświadczeń platformy Azure)
• Nowa aplikacja konsolowa

Krok 1. Instalowanie pakietów NuGet

Najpierw zainstaluj wymagane pakiety dla projektu .NET:

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.Workflows --prerelease

Krok 2. Konfigurowanie klienta usługi Azure Foundry

Skonfiguruj klienta usługi Azure Foundry przy użyciu zmiennych środowiskowych i uwierzytelniania:

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure AI Project client
        var endpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
            ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("FOUNDRY_MODEL") ?? "gpt-4o-mini";
        var aiProjectClient = new AIProjectClient(new Uri(endpoint), new AzureCliCredential());

Krok 3. Tworzenie metody fabryki agentów

Zaimplementuj metodę pomocnika, aby utworzyć agentów usługi Azure Foundry z określonymi instrukcjami:

    /// <summary>
    /// Creates a translation agent for the specified target language.
    /// </summary>
    /// <param name="targetLanguage">The target language for translation</param>
    /// <param name="aiProjectClient">The AIProjectClient to create the agent</param>
    /// <param name="model">The model to use for the agent</param>
    /// <returns>A FoundryAgent configured for the specified language</returns>
    private static async Task<FoundryAgent> GetTranslationAgentAsync(
        string targetLanguage,
        AIProjectClient aiProjectClient,
        string model)
    {
        string agentName = $"{targetLanguage}Translator";
        var version = await aiProjectClient.AgentAdministrationClient.CreateAgentVersionAsync(
            agentName,
            new ProjectsAgentVersionCreationOptions(
                new DeclarativeAgentDefinition(model)
                {
                    Instructions = $"You are a translation assistant that translates the provided text to {targetLanguage}."
                }));

        return aiProjectClient.AsAIAgent(version);
    }
}

Krok 4. Tworzenie wyspecjalizowanych agentów usługi Azure Foundry

Utwórz trzech agentów tłumaczenia przy użyciu metody pomocniczej:

        // Create agents
        AIAgent frenchAgent = await GetTranslationAgentAsync("French", aiProjectClient, deploymentName);
        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", aiProjectClient, deploymentName);
        AIAgent englishAgent = await GetTranslationAgentAsync("English", aiProjectClient, deploymentName);

Krok 5. Tworzenie przepływu pracy

Połącz agentów w przepływie pracy sekwencyjnej przy użyciu programu WorkflowBuilder:

        // Build the workflow by adding executors and connecting them
        var workflow = new WorkflowBuilder(frenchAgent)
            .AddEdge(frenchAgent, spanishAgent)
            .AddEdge(spanishAgent, englishAgent)
            .Build();

Krok 6: Wykonywanie z użyciem przesyłania strumieniowego

Uruchom przepływ pracy z funkcją strumieniowania, aby śledzić aktualizacje w czasie rzeczywistym od wszystkich agentów.

        // Execute the workflow
        await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, new ChatMessage(ChatRole.User, "Hello World!"));

        // Must send the turn token to trigger the agents.
        // The agents are wrapped as executors. When they receive messages,
        // they will cache the messages and only start processing when they receive a TurnToken.
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
        await foreach (WorkflowEvent evt in run.WatchStreamAsync())
        {
            if (evt is AgentResponseUpdateEvent executorComplete)
            {
                Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
            }
        }

Krok 7. Oczyszczanie zasobów

Prawidłowo wyczyść agentów usługi Azure Foundry po użyciu:

        // Cleanup the agents created for the sample.
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(frenchAgent.Name);
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(spanishAgent.Name);
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(englishAgent.Name);
    }

Jak to działa

1. Azure Foundry Client Setup: używa AIProjectClient z poświadczeniami Azure CLI do uwierzytelniania
2. Tworzenie agentów: Wersjonowanie agentów w usłudze Azure Foundry z określonymi instrukcjami dotyczącymi tłumaczenia
3. Przetwarzanie sekwencyjne: francuski agent tłumaczy najpierw dane wejściowe, a następnie hiszpański agent, a następnie angielski agent
4. Wzorzec tokenu 'Turn': agenci buforują komunikaty i przetwarzają dopiero po otrzymaniu TurnToken
5. Aktualizacje strumieniowe: AgentResponseUpdateEvent zapewniają aktualizacje tokenów w czasie rzeczywistym, gdy agenci generują odpowiedzi
6. Zarządzanie zasobami: prawidłowe czyszczenie agentów usługi Azure Foundry przy użyciu interfejsu API administracyjnego

Kluczowe pojęcia

• Usługa agenta usługi Azure Foundry: agenci sztucznej inteligencji opartej na chmurze z zaawansowanymi możliwościami rozumowania
• AIProjectClient: klient do tworzenia agentów i zarządzania nimi w usłudze Azure Foundry
• WorkflowEvent: Zdarzenia wyjściowe (type="output") zawierają dane wyjściowe agenta (AgentResponseUpdate dla przesyłania strumieniowego, AgentResponse dla nieprzesyłania strumieniowego)
• TurnToken: sygnał wyzwalający przetwarzanie agenta po buforowaniu komunikatów
• Sekwencyjny przepływ pracy: agenty połączeni w potoku, w którym dane wyjściowe przepływają od jednego do kolejnego

Kompletna implementacja

Aby uzyskać pełną działającą implementację tego przepływu pracy agentów usługi Azure Foundry, zobacz przykład foundryAgent Program.cs w repozytorium Platformy agentów.

Co będziesz budować

Utworzysz przepływ pracy, który:

• Użycie FoundryChatClient do tworzenia inteligentnych agentów
• Implementuje agenta piszącego, który tworzy zawartość na podstawie poleceń
• Implementuje agenta recenzenta, który przekazuje opinię na temat zawartości
• Łączy agentów w sekwencyjnej ścieżce pracy.
• Przesyła strumieniowo aktualizacje w czasie rzeczywistym, gdy agenci przetwarzają żądania

Omówione pojęcia

• Agenci w przepływach pracy
• Krawędzie bezpośrednie
• Konstruktor przepływu pracy

Wymagania wstępne

• Python 3.11 lub nowszy
• Zainstalowano program Agent Framework: pip install agent-framework
• Odpowiedzi usługi Azure OpenAI skonfigurowane z odpowiednimi zmiennymi środowiskowymi
• Uwierzytelnianie Azure CLI: az login

Krok 1. Importowanie wymaganych zależności

Zacznij od zaimportowania niezbędnych składników dla przepływów pracy i agentów odpowiedzi usługi Azure OpenAI:

import asyncio
import os

from agent_framework import AgentResponseUpdate, WorkflowBuilder
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

Krok 2. Tworzenie klienta odpowiedzi usługi Azure OpenAI

Utwórz jednego udostępnionego klienta, którego można użyć do konstruowania wielu agentów:

async def main() -> None:
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        model=os.environ["FOUNDRY_MODEL"],
        credential=AzureCliCredential(),
    )

Krok 3. Tworzenie wyspecjalizowanych agentów

Utwórz dwóch wyspecjalizowanych agentów do tworzenia i przeglądu zawartości.

    # Create a Writer agent that generates content
    writer_agent = client.as_agent(
        name="Writer",
        instructions=(
            "You are an excellent content writer. You create new content and edit contents based on the feedback."
        ),
    )

    # Create a Reviewer agent that provides feedback
    reviewer_agent = client.as_agent(
        name="Reviewer",
        instructions=(
            "You are an excellent content reviewer. "
            "Provide actionable feedback to the writer about the provided content. "
            "Provide the feedback in the most concise manner possible."
        ),
    )

Krok 4. Kompilowanie przepływu pracy

Połącz agentów w przepływie pracy sekwencyjnej przy użyciu konstruktora:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(start_executor=writer_agent).add_edge(writer_agent, reviewer_agent).build()

Krok 5: Wykonanie z użyciem transmisji strumieniowej

Uruchom przepływ pracy z przesyłaniem strumieniowym, aby obserwować aktualizacje w czasie rzeczywistym od obu agentów:

    last_author: str | None = None

    events = workflow.run("Create a slogan for a new electric SUV that is affordable and fun to drive.", stream=True)
    async for event in events:
        if event.type == "output" and isinstance(event.data, AgentResponseUpdate):
            update = event.data
            author = update.author_name
            if author != last_author:
                if last_author is not None:
                    print()
                print(f"{author}: {update.text}", end="", flush=True)
                last_author = author
            else:
                print(update.text, end="", flush=True)

Krok 6: Ukończ funkcję Main

Zawijaj wszystko w funkcji main przy użyciu prawidłowego wykonywania asynchronicznego:

if __name__ == "__main__":
    asyncio.run(main())

Jak to działa

1. Konfiguracja klienta: korzysta z jednego FoundryChatClient z poświadczeniami Azure CLI do uwierzytelniania.
2. Tworzenie agenta: Tworzy agentów Piszącego i Przeglądającego na podstawie tej samej konfiguracji klienta.
3. Przetwarzanie sekwencyjne: agent modułu zapisywania najpierw generuje zawartość, a następnie przekazuje ją do agenta recenzenta.
4. Aktualizacje przesyłania strumieniowego: zdarzenia wyjściowe (type="output") z AgentResponseUpdate danymi zapewniają aktualizacje tokenów w czasie rzeczywistym, gdy agenci generują odpowiedzi.

Kluczowe pojęcia

• FoundryChatClient: udostępniony klient używany do tworzenia agentów przepływu pracy z spójną konfiguracją.
• WorkflowEvent: zdarzenia wyjściowe (type="output") zawierają dane wyjściowe agenta (AgentResponseUpdate dla przesyłania strumieniowego, AgentResponse dla trybu nieprzesyłania strumieniowego).
• Sekwencyjny przepływ zadań: agenty połączeni w potoku, w którym dane wyjściowe przepływają od jednego do drugiego.

Kompletna implementacja

Aby uzyskać pełną działającą implementację, zobacz azure_ai_agents_streaming.py w repozytorium Platformy agentów.

Co będziesz budować

Utworzysz przepływ pracy, który:

• Używa agentów wdrażania modelu Microsoft Foundry jako wykonawców przepływu pracy
• Implementuje francuskiego agenta tłumaczenia
• Implementuje hiszpańskiego agenta tłumaczenia
• Implementuje agenta tłumaczenia w języku angielskim
• Łączy agentów w sekwencyjnej ścieżce pracy.
• Przesyła strumieniowo aktualizacje w czasie rzeczywistym, gdy agenci przetwarzają żądania

Omówione pojęcia

• Agenci w przepływach pracy
• Krawędzie bezpośrednie
• Konstruktor przepływu pracy

Wymagania wstępne

• Go 1.26 lub nowsza
• Skonfigurowano punkt końcowy projektu Microsoft Foundry oraz wdrożenie modelu
• uwierzytelnianie za pomocą interfejsu wiersza polecenia platformy Azure lub inne źródło poświadczeń Azure

W nowym katalogu zainicjuj moduł Go i zainstaluj Agent Framework:

go mod init example.com/agent-workflow
go get github.com/microsoft/agent-framework-go

Ustaw punkt końcowy projektu i nazwę wdrożonego modelu:

$env:FOUNDRY_PROJECT_ENDPOINT = "https://<resource>.services.ai.azure.com/api/projects/<project>"
$env:FOUNDRY_MODEL = "<deployment-name>"

Krok 1. Konfigurowanie konfiguracji rozwiązania Foundry

Poniższe sekcje przedstawiają tworzenie funkcji runExample w pełnej implementacji. Rozpocznij od importowania i konfiguracji:

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/message"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
    "github.com/microsoft/agent-framework-go/workflow"
    "github.com/microsoft/agent-framework-go/workflow/agentworkflow"
    "github.com/microsoft/agent-framework-go/workflow/inproc"
)

endpoint := strings.TrimSpace(os.Getenv("FOUNDRY_PROJECT_ENDPOINT"))
if endpoint == "" {
    return fmt.Errorf("set FOUNDRY_PROJECT_ENDPOINT")
}
model := strings.TrimSpace(os.Getenv("FOUNDRY_MODEL"))
if model == "" {
    return fmt.Errorf("set FOUNDRY_MODEL to your model deployment name")
}

token, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    return err
}

Warning

azidentity.NewDefaultAzureCredential jest wygodne do programowania, ale wymaga starannego rozważenia w środowisku produkcyjnym. W środowisku produkcyjnym rozważ użycie konkretnego poświadczenia, takiego jak azidentity.NewManagedIdentityCredential, aby uniknąć opóźnień, niezamierzonego sprawdzania poświadczeń oraz potencjalnych zagrożeń bezpieczeństwa wynikających z mechanizmów awaryjnych.

Krok 2. Tworzenie funkcji fabryki agentów

Tworzenie agentów z określonymi instrukcjami tłumaczenia:

newTranslationAgent := func(language string) *agent.Agent {
    return foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
        Instructions: fmt.Sprintf(
            "Translate the user's text to %s. Return only the translation.",
            language,
        ),
        Config: agent.Config{Name: language + "Agent"},
    })
}

Krok 3: Utwórz wyspecjalizowane agenty Foundry

frenchAgent := newTranslationAgent("French")
spanishAgent := newTranslationAgent("Spanish")
englishAgent := newTranslationAgent("English")

Krok 4. Kompilowanie przepływu pracy

Agenci mogą służyć jako funkcje wykonawcze przepływu pracy, włączając kroki przepływu pracy oparte na sztucznej inteligencji.

Przypisz każdego agenta jako wykonawcę przepływu pracy, a następnie połącz wykonawców krawędziami:

cfg := agentworkflow.Config{ForwardIncomingMessages: new(false)}
french := agentworkflow.New(frenchAgent, cfg)
spanish := agentworkflow.New(spanishAgent, cfg)
english := agentworkflow.New(englishAgent, cfg)

wf, err := workflow.NewBuilder(french).
    AddEdge(french, spanish).
    AddEdge(spanish, english).
    WithIntermediateOutputFrom(french, spanish).
    WithOutputFrom(english).
    Build()
if err != nil {
    return err
}

ForwardIncomingMessages: new(false) przekazuje dalej odpowiedź każdego agenta bez przekazywania również danych wejściowych tego agenta. Każdy hostowany egzekutor zarządza własną sesją agenta.

Zarejestruj język francuski i hiszpański jako pośrednie źródła wyjścia, aby osoby wywołujące mogły obserwować wszystkich trzech agentów. Język angielski pozostaje źródłem danych wyjściowych terminala. Oznaczenie danych wyjściowych steruje tym, co widzi wywołujący, a nie tym, które komunikaty przepływają wzdłuż krawędzi.

Krok 5: Wykonanie z użyciem transmisji strumieniowej

Uruchom przepływ pracy i włącz zdarzenia aktualizacji za pomocą workflow.TurnToken. Obsługuj zdarzenia niepowodzenia przepływu pracy oraz błędy z iteratora zdarzeń:

run, err := inproc.Default.RunStreaming(ctx, wf, message.NewText("Hello World"))
if err != nil {
    return err
}
defer func() {
    err = errors.Join(err, run.Close(context.WithoutCancel(ctx)))
}()

emitEvents := true
if accepted, err := run.TrySendMessage(ctx, workflow.TurnToken{EmitEvents: &emitEvents}); err != nil {
    return err
} else if !accepted {
    return fmt.Errorf("workflow doesn't accept turn tokens")
}

lastExecutorID := ""
for evt, streamErr := range run.WatchStream(ctx) {
    if streamErr != nil {
        return streamErr
    }
    switch event := evt.(type) {
    case workflow.OutputEvent:
        update, ok := event.Output.(*agent.ResponseUpdate)
        if !ok || update.String() == "" {
            continue
        }
        if event.ExecutorID != lastExecutorID {
            if lastExecutorID != "" {
                fmt.Println()
            }
            fmt.Printf("%s: ", event.ExecutorID)
            lastExecutorID = event.ExecutorID
        }
        fmt.Print(update.String())
    case workflow.ErrorEvent:
        return event.Error
    case workflow.ExecutorFailedEvent:
        return fmt.Errorf("executor %q failed: %w",
            event.ExecutorID, event.Error)
    }
}
if lastExecutorID != "" {
    fmt.Println()
}

Dane wyjściowe zawierają tłumaczenia francuskie, hiszpańskie i angielskie, pogrupowane według wykonawcy. Kompletny przykład wraca z runExample przed zarejestrowaniem błędu krytycznego, więc odroczone czyszczenie przepływu pracy nadal działa.

W przeciwieństwie do przykładu w języku C# ten przykład w języku Go nie tworzy zapisanych wersji agenta, które wymagają usunięcia w narzędziu Foundry.

Jak to działa

1. Konfiguracja klienta: używa punktu końcowego projektu Foundry, wdrożenia modelu i poświadczeń Azure.
2. Tworzenie agenta: tworzy wyspecjalizowanych agentów z instrukcjami specyficznymi dla języka.
3. Hostowanie agenta: Używa agentworkflow.New, aby powiązać każdego agenta jako wykonawcę przepływu pracy.
4. Przetwarzanie sekwencyjne: najpierw uruchamiany jest moduł wykonawczy dla języka francuskiego, następnie hiszpańskiego, a na końcu angielskiego.
5. Włącz wzorzec tokenu: hostowani agenci buforują komunikaty i uruchamiają je po otrzymaniu elementu workflow.TurnToken.
6. Aktualizacje strumieniowe: pośrednie i końcowe wyniki wyjściowe uwidaczniają aktualizacje wszystkich trzech agentów.
7. Obsługa błędów: Host sprawdza ErrorEvent i ExecutorFailedEvent, a następnie zamyka przebieg przepływu pracy przed zgłoszeniem awarii.

Kluczowe pojęcia

• Agent Foundry: agent.Agent Agent oparty na wdrożeniu modelu Foundry.
• agentworkflow.New: Dostosowuje agenta do używania jako modułu wykonawczego przepływu pracy.
• workflow.TurnToken: sygnał, który wyzwala hostowanych agentów do przetwarzania komunikatów z bufora.
• OutputEvent przepływu pracy: zawiera aktualizacje odpowiedzi agenta i końcowe wyniki przepływu pracy.
• Sekwencyjny przepływ zadań: agenty połączeni w potoku, w którym dane wyjściowe przepływają od jednego do drugiego.

Kompletna implementacja

Zapisz ten przykład jako main.go w module Go:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/message"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
    "github.com/microsoft/agent-framework-go/workflow"
    "github.com/microsoft/agent-framework-go/workflow/agentworkflow"
    "github.com/microsoft/agent-framework-go/workflow/inproc"
)

func main() {
    if err := runExample(context.Background()); err != nil {
        log.Fatal(err)
    }
}

func runExample(ctx context.Context) (err error) {
    endpoint := strings.TrimSpace(os.Getenv("FOUNDRY_PROJECT_ENDPOINT"))
    if endpoint == "" {
        return fmt.Errorf("set FOUNDRY_PROJECT_ENDPOINT")
    }
    model := strings.TrimSpace(os.Getenv("FOUNDRY_MODEL"))
    if model == "" {
        return fmt.Errorf("set FOUNDRY_MODEL to your model deployment name")
    }

    token, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        return err
    }

    newTranslationAgent := func(language string) *agent.Agent {
        return foundryprovider.NewAgent(
            endpoint,
            token,
            foundryprovider.ModelDeployment(model),
            foundryprovider.AgentConfig{
                Instructions: fmt.Sprintf(
                    "Translate the user's text to %s. Return only the translation.",
                    language,
                ),
                Config: agent.Config{Name: language + "Agent"},
            },
        )
    }

    cfg := agentworkflow.Config{ForwardIncomingMessages: new(false)}
    french := agentworkflow.New(newTranslationAgent("French"), cfg)
    spanish := agentworkflow.New(newTranslationAgent("Spanish"), cfg)
    english := agentworkflow.New(newTranslationAgent("English"), cfg)

    wf, err := workflow.NewBuilder(french).
        AddEdge(french, spanish).
        AddEdge(spanish, english).
        WithIntermediateOutputFrom(french, spanish).
        WithOutputFrom(english).
        Build()
    if err != nil {
        return err
    }

    run, err := inproc.Default.RunStreaming(ctx, wf, message.NewText("Hello World"))
    if err != nil {
        return err
    }
    defer func() {
        err = errors.Join(err, run.Close(context.WithoutCancel(ctx)))
    }()

    emitEvents := true
    if accepted, err := run.TrySendMessage(ctx, workflow.TurnToken{EmitEvents: &emitEvents}); err != nil {
        return err
    } else if !accepted {
        return fmt.Errorf("workflow doesn't accept turn tokens")
    }

    lastExecutorID := ""
    for evt, streamErr := range run.WatchStream(ctx) {
        if streamErr != nil {
            return streamErr
        }
        switch event := evt.(type) {
        case workflow.OutputEvent:
            update, ok := event.Output.(*agent.ResponseUpdate)
            if !ok || update.String() == "" {
                continue
            }
            if event.ExecutorID != lastExecutorID {
                if lastExecutorID != "" {
                    fmt.Println()
                }
                fmt.Printf("%s: ", event.ExecutorID)
                lastExecutorID = event.ExecutorID
            }
            fmt.Print(update.String())
        case workflow.ErrorEvent:
            return event.Error
        case workflow.ExecutorFailedEvent:
            return fmt.Errorf("executor %q failed: %w",
                event.ExecutorID, event.Error)
        }
    }
    if lastExecutorID != "" {
        fmt.Println()
    }
    return nil
}

Uruchom przykład:

go run .

Warning

azidentity.NewDefaultAzureCredential jest wygodne do programowania, ale wymaga starannego rozważenia w środowisku produkcyjnym. W środowisku produkcyjnym rozważ użycie konkretnego poświadczenia, takiego jak azidentity.NewManagedIdentityCredential, aby uniknąć opóźnień, niezamierzonego sprawdzania poświadczeń oraz potencjalnych zagrożeń bezpieczeństwa wynikających z mechanizmów awaryjnych.

Tip

Zobacz przykład agentów w przepływach pracy dla innego potoku tłumaczenia możliwego do uruchomienia.

Dalsze kroki

Człowiek w pętli