使用 Temporal Go SDK 的示例
This repository contains several sample Workflow applications that demonstrate the various capabilities of the Temporal Server via the Temporal Go SDK.
The helloworld sample is a good place to start.
Each sample demonstrates one feature of the SDK, together with tests.
Basic hello world: Simple example of a Workflow Definition and an Activity Definition.
Basic mTLS hello world: Simple example of a Workflow Definition and an Activity Definition using mTLS like Temporal Cloud.
Dynamic mTLS hello world: Simple example showing how to refresh mTLS credentials. This allows for credentials to be refreshed without restarting the worker.
Basic apiKey hello world: Simple example of a Workflow Definition and an Activity Definition using API Key to authenticate with Temporal Cloud.
Basic external environment configuration: Simple example showing how to configure a client with an external configuration file, like TOML, decoupling connection settings from application code.
Standalone Activities: Demonstrates how standalone activities work, where activities can be called from the client directly and not wrapped in an activity.
Async activity completion: Example of an Expense reporting Workflow that communicates with a server API. Additional documentation: How to complete an Activity Execution asynchronously in Go
Retry Activity Execution: This sample executes an unreliable Activity. The Activity is executed with a custom Retry Policy. If the Activity Execution fails, the Server will schedule a retry based on the Retry Policy. This Activity also includes a Heartbeat, which enables it to resume from the Activity Execution's last reported progress when it retries.
Child Workflow: Demonstrates how to use execute a Child Workflow from a Parent Workflow Execution. A Child Workflow Execution only returns to the Parent Workflow Execution after completing its last Run.
Child Workflow with ContinueAsNew: Demonstrates that the call to Continue-As-New, by a Child Workflow Execution, is not visible to the parent. The Parent Workflow Execution receives a notification only when a Child Workflow Execution completes, fails or times out. This is a useful feature when there is a need to process a large set of data. The child can iterate over the data set calling Continue-As-New periodically without polluting the parents' history.
Cancellation: Demonstrates how to cancel a
Workflow Execution by calling CancelWorkflow, and how to defer an Activity Execution that "cleans up" after the
Workflow Execution has been cancelled.
Coroutines: Do not use native go routines in Workflows. Instead use Temporal coroutines (workflow.Go()) to
maintain a deterministic Workflow. Can be
seen in the Goroutine
, DSL
, Recovery
, PSO Workflow examples.
Cron Workflow: Demonstrates a recurring Workflow
Execution that occurs according to a cron schedule. This sample showcases the HasLastCompletionResult and
GetLastCompletionResult APIs which are used to pass information between executions. Note that we recommend
using Schedules instead of Cron Jobs.
Additional documentation: What is a Temporal Cron Job?.
Schedule Workflow: Demonstrates a recurring Workflow Execution that occurs according to a schedule. documentation: Schedule.
Encryption: How to use encryption for Workflow/Activity data with the DataConverter API. Also includes an example of stacking encoders (in this case encryption and compression)
Codec Server: Demonstrates using a codec server to decode payloads for display in Temporal CLI and Temporal Web. This setup can be used for any kind of codec, common examples are compression or encryption.
External Storage: Offload large payloads to S3-compatible object storage plus a codec server built on the SDK's payload HTTP handler so the Web UI and CLI can decode and download the externally-stored payloads.
Query Example: Demonstrates how to Query the state
of a single Workflow Execution using the QueryWorkflow and SetQueryHandler APIs. Additional
documentation: How to Query a Workflow Execution in Go.
Selectors: Do not use the native Go select statement. Instead
use Go SDK Selectors (selector.Select(ctx)) to maintain
a deterministic Workflow. Can be seen in
the Pick First
, Mutex
, DSL,
and Timer examples.
Sessions: Demonstrates how to bind a set of Activity Executions to a specific Worker after the first Activity executes. This feature is showcased in the File Processing example. Addition documentation: How to use Sessions in Go.
Signals: Can be seen in the Recovery and Mutex examples. Additional documentation: eCommerce application tutorial , How to send Signals , How to handle Signals .
Memo: Demonstrates how to use Memo that can be used to store any kind of data.
Search Attributes: Demonstrates how to use custom Search Attributes that can be used to find Workflow Executions using predicates.
Timer Futures: The sample starts a long running
order processing operation and starts a Timer (workflow.NewTimer()). If the processing time is too long, a
notification email is "sent" to the user regarding the delay (the execution does not cancel). If the operation
finishes before the Timer fires, then the Timer is cancelled.
Tracing and Context Propagation:
Demonstrates the client initialization with a context propagator, which propagates specific information in
the context.Context object across the Workflow Execution. The context.Context object is populated with information
prior to calling StartWorkflow. This example demonstrates that the information is available in the Workflow
Execution and Activity Executions. Additional
documentation: How to use tracing in Go.
OpenTelemetry: Demonstrates how to instrument the Workflows and Activities with OpenTelemetry.
OpenTelemetry v2: Demonstrates replay-safe OpenTelemetry instrumentation with the v2 plugin. The automatic instrumentation sample enables Temporal SDK operation spans and metrics. The custom Workflow-to-Activity and Client-to-Update samples create application spans.
Updatable Timer: Demonstrates timer cancellation and use of a Selector to wait on a Future and a Channel simultaneously.
Greetings: Demonstrates how to pass dependencies to activities defined as struct methods.
Greetings Local: Demonstrates how to pass dependencies to local activities defined as struct methods.
Logging Interceptor: Demonstrates how to use interceptors to intercept calls, in this case for adding context to the logger.
Workflow Security Interceptor: Demonstrates how to use interceptors to intercept child workflow calls, in this case for validating their type.
Update: Demonstrates how to create a workflow that reacts to workflow update requests.
Eager Workflow Start: Demonstrates how to start a workflow in eager mode, an experimental latency optimization.
Workflow Streams: Demonstrates a durable publish/subscribe
log hosted inside a workflow using the workflowstreams contrib package: external code
publishes to named topics via signals, subscribers long-poll via updates, and a query
exposes the current offset. Includes five scenarios — basic publish/subscribe, a
reconnecting subscriber, an external publisher, a truncating ticker, and LLM token
streaming.
Google ADK agent: Demonstrates running Google ADK (adk-go) agents
durably using the googleadk contrib integration: the agent loop runs in a Workflow, the
model call runs as an Activity, and a tool is exposed as a durable Activity via
ActivityAsTool. Includes scenario subdirectories for a multi-agent
system, human-in-the-loop tool approval (durable wait on a
signal), a continue-as-new chat, and model-usage
metrics.
These samples demonstrate some common control flow patterns using Temporal's Go SDK API.
Dynamic Workflows: Demonstrates how to execute Workflows and Activities dynamically, using a single "Dynamic Workflow"
Dynamic Execution: Demonstrates how to execute Workflows and Activities using a name rather than a strongly typed function.
Branching Activities: Executes multiple Activities in parallel. The number of branches is controlled by a parameter that is passed in at the start of the Workflow Execution.
Exclusive Choice: Demonstrates how to execute Activities based on a dynamic input.
Multi-Choice: Demonstrates how to execute multiple Activities in parallel based on a dynamic input.
Mutex Workflow: Demonstrates the ability to lock/unlock a particular resource within a particular Temporal Namespace. In this examples the other Workflow Executions within the same Namespace wait until a locked resource is unlocked. This shows how to avoid race conditions or parallel mutually exclusive operations on the same resource.
Goroutine Workflow: This sample executes
multiple sequences of activities in parallel using the workflow.Go() API.
Pick First: This sample executes Activiti
暂无开放 Issues，或尚未同步最近议题。