Temporal Platform

https://docs.temporal.io
Admin
Temporal Platform is a durable execution system that enables developers to build and operate...
Tokens:884,012
Snippets:11,105
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install and Start Temporal CLI

Source: https://docs.temporal.io/guides/recover-without-restart.md

Commands to install the Temporal CLI and initialize a local development server.

```bash
# macOS
brew install temporal

# Or download directly from https://docs.temporal.io/cli#install

# Start the local development server
temporal server start-dev
```

--------------------------------

### Verify SDK installation output

Source: https://docs.temporal.io/develop/ruby/set-up-local-ruby.md

Example output confirming the successful installation of the temporalio gem.

```bash
Fetching gem metadata from https://rubygems.org/...
Resolving dependencies...
Installing temporalio 0.4.0 (arm64-darwin)
Bundle complete! 1 Gemfile dependency, 6 gems now installed.
```

--------------------------------

### Initialize and run a Worker process

Source: https://docs.temporal.io/develop/php/workers/run-worker-process.md

Demonstrates the basic setup for a Worker process, including registering workflow and activity types and starting the factory loop.

```php
<?php

declare(strict_types=1);

use Temporal\WorkerFactory;

ini_set('display_errors', 'stderr');
include "vendor/autoload.php";

// factory initiates and runs task queue specific activity and workflow workers
$factory = WorkerFactory::create();

// Worker that listens on a Task Queue and hosts both workflow and activity implementations.
$worker = $factory->newWorker();

// Workflows are stateful. So you need a type to create instances.
$worker->registerWorkflowTypes(App\DemoWorkflow::class);

// Activities are stateless and thread safe. So a shared instance is used.
$worker->registerActivity(App\DemoActivity::class);

// In case an activity class requires some external dependencies provide a callback - factory
// that creates or builds a new activity instance. The factory should be a callable which accepts
// an instance of ReflectionClass with an activity class which should be created.
$worker->registerActivity(App\DemoActivity::class, fn(ReflectionClass $class) => $container->create($class->getName()));

// start primary loop
$factory->run();
```

--------------------------------

### Start a Workflow Execution

Source: https://docs.temporal.io/cli/command-reference/workflow.md

Example command for initiating a workflow execution with specific configuration parameters.

```bash
  --update-wait-for-stage accepted \
  --workflow-id YourWorkflowId \
  --type YourWorkflowType \
  --task-queue YourTaskQueue \
  --id-conflict-policy Fail \
  --input '{"wf-key": "wf-value"}'
```

--------------------------------

### Configure Cassandra and MySQL Visibility Stores

Source: https://docs.temporal.io/self-hosted-guide/visibility/dual-visibility.md

Example shell script for setting environment variables and running schema setup tools for Cassandra and MySQL visibility stores.

```bash
#...
# set your Cassandra environment variables
: "${KEYSPACE:=temporal}"
: "${VISIBILITY_KEYSPACE:=temporal_primary_visibility}"

: "${CASSANDRA_SEEDS:=}"
: "${CASSANDRA_PORT:=9042}"
: "${CASSANDRA_USER:=}"
: "${CASSANDRA_PASSWORD:=}"
: "${CASSANDRA_TLS_ENABLED:=}"
: "${CASSANDRA_CERT:=}"
: "${CASSANDRA_CERT_KEY:=}"
: "${CASSANDRA_CA:=}"
: "${CASSANDRA_REPLICATION_FACTOR:=1}"
#...
# set connection details
#...
# set up Cassandra schema
setup_cassandra_schema() {
  #...
  # use valid schema for the version of the database you want to set up for Visibility
    VISIBILITY_SCHEMA_DIR=${TEMPORAL_HOME}/schema/cassandra/visibility/versioned
    if [[ ${SKIP_DB_CREATE} != true ]]; then
        temporal-cassandra-tool --ep "${CASSANDRA_SEEDS}" create -k "${VISIBILITY_KEYSPACE}" --rf "${CASSANDRA_REPLICATION_FACTOR}"
    fi
    temporal-cassandra-tool --ep "${CASSANDRA_SEEDS}" -k "${VISIBILITY_KEYSPACE}" setup-schema -v 0.0
    temporal-cassandra-tool --ep "${CASSANDRA_SEEDS}" -k "${VISIBILITY_KEYSPACE}" update-schema -d "${VISIBILITY_SCHEMA_DIR}"
  #...
}
#...
# set your MySQL environment variables
: "${DBNAME:=temporal}"
: "${VISIBILITY_DBNAME:=temporal_secondary_visibility}"
: "${DB_PORT:=}"
: "${MYSQL_SEEDS:=}"
: "${MYSQL_USER:=}"
: "${MYSQL_PWD:=}"
: "${MYSQL_TX_ISOLATION_COMPAT:=false}"

#...
# set connection details
#...
# set up MySQL schema
setup_mysql_schema() {
    #...
    # use valid schema for the version of the database you want to set up for Visibility
    VISIBILITY_SCHEMA_DIR=${TEMPORAL_HOME}/schema/mysql/${MYSQL_VERSION_DIR}/visibility/versioned
    if [[ ${SKIP_DB_CREATE} != true ]]; then
        temporal-sql-tool --ep "${MYSQL_SEEDS}" -u "${MYSQL_USER}" -p "${DB_PORT}" "${MYSQL_CONNECT_ATTR[@]}" --db "${VISIBILITY_DBNAME}" create
    fi
    temporal-sql-tool --ep "${MYSQL_SEEDS}" -u "${MYSQL_USER}" -p "${DB_PORT}" "${MYSQL_CONNECT_ATTR[@]}" --db "${VISIBILITY_DBNAME}" setup-schema -v 0.0
    temporal-sql-tool --ep "${MYSQL_SEEDS}" -u "${MYSQL_USER}" -p "${DB_PORT}" "${MYSQL_CONNECT_ATTR[@]}" --db "${VISIBILITY_DBNAME}" update-schema -d "${VISIBILITY_SCHEMA_DIR}"
#...
}
```

--------------------------------

### Install dependencies

Source: https://docs.temporal.io/ai-cookbook/human-in-the-loop-python.md

Install project dependencies using uv.

```bash
uv sync
```

--------------------------------

### View Temporal CLI help options

Source: https://docs.temporal.io/develop/run-a-development-server.md

Display available configuration options for the development server startup command.

```bash
temporal server start-dev --help
```

--------------------------------

### Run the sample client

Source: https://docs.temporal.io/develop/typescript/activities/standalone-activities-quickstart.md

Command to execute the sample client program.

```bash
npm run execute
```

--------------------------------

### Run Starter Program

Source: https://docs.temporal.io/develop/go/activities/standalone-activities-quickstart.md

Command to execute the Go starter program.

```bash
go run standalone-activity/helloworld/starter/main.go
```

--------------------------------

### Start and Configure Workflow Task Queues in TypeScript

Source: https://docs.temporal.io/task-queue/naming.md

Examples of setting the taskQueue property when starting a workflow and creating a worker.

```typescript
await client.workflow.start(OrderProcessingWorkflow, {
  args: [order],
  taskQueue: 'my-task-queue',
  workflowId: `workflow-order-${order.id},`,
});
```

```typescript
const worker = await Worker.create({
  taskQueue: 'my-task-queue',
  connection,
  workflowsPath: require.resolve('./workflows'),
  activities,
});
```

--------------------------------

### Create the Workflow Starter

Source: https://docs.temporal.io/ai-cookbook/hello-world-litellm-python.md

Connects to the Temporal server and executes the HelloWorld workflow with a specific task queue.

```python
import asyncio

from temporalio.client import Client
from temporalio.contrib.pydantic import pydantic_data_converter

from workflows.hello_world_workflow import HelloWorld

async def main():
    client = await Client.connect(
        "localhost:7233",
        data_converter=pydantic_data_converter,
    )

    # Submit the Hello World workflow for execution
    result = await client.execute_workflow(
        HelloWorld.run,
        "Tell me about recursion in programming.",
        id="my-workflow-id",
        task_queue="hello-world-python-task-queue",
    )
    print(f"Result: {result}")

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

--------------------------------

### Start and Configure Workflow Task Queues in Go

Source: https://docs.temporal.io/task-queue/naming.md

Examples of setting the TaskQueue option when starting a workflow and configuring a worker.

```go
options := client.StartWorkflowOptions{
    ID:        "my-workflow",
    TaskQueue: "my-task-queue-name",
}

run, err := c.ExecuteWorkflow(ctx, options, ProcessOrderWorkflow, input)
```

```go
w := worker.New(c, "my-task-queue-name", worker.Options{})
```

--------------------------------

### Start and Configure Workflow Task Queues in Python

Source: https://docs.temporal.io/task-queue/naming.md

Examples of setting the task_queue parameter when starting a workflow and configuring a worker.

```python
client = await Client.connect("localhost:7233", namespace="default")

# Execute a workflow
result = await client.execute_workflow(
    GreetingWorkflow.run,
    name,
    id="my-workflow",
    task_queue="my-task-queue-name",
)
```

```python
worker = Worker(
    client,
    task_queue="my-task-queue-name",
    workflows=[GreetingWorkflow],
    activities=[activities.say_hello],
)
```

--------------------------------

### Initialize and Start a Temporal Server

Source: https://docs.temporal.io/references/server-options.md

Basic pattern for creating a new server instance and starting it with error handling.

```go
s, err := temporal.NewServer()
if err != nil {
    log.Fatal(err)
}
err = s.Start()
if err != nil{
    log.Fatal(err)
}
```

--------------------------------

### Set up virtual environment

Source: https://docs.temporal.io/develop/python/set-up-your-local-python.md

Create and activate a Python virtual environment.

```bash
python3 -m venv env
```

```bash
source env/bin/activate
```

--------------------------------

### Start and Configure Workflow Task Queues in .NET

Source: https://docs.temporal.io/task-queue/naming.md

Examples of setting the task queue in WorkflowOptions and TemporalWorkerOptions.

```csharp
var options = new WorkflowOptions(
            id: "translation-workflow",
            taskQueue: "my-task-queue");

// Run workflow
var result = await client.ExecuteWorkflowAsync(
    (TranslationWorkflow wf) => wf.RunAsync(input),
    options);
```

```csharp
using var worker = new TemporalWorker(
    client,
    new TemporalWorkerOptions("my-task-queue")
    .AddAllActivities(activities)
    .AddWorkflow<TestWorkflow>());
```

--------------------------------

### Initialize a Go project

Source: https://docs.temporal.io/develop/go/set-up-your-local-go.md

Commands to create a directory and initialize a new Go module.

```bash
mkdir goproject
```

```bash
cd goproject
```

```bash
go mod init my-org/greeting
```

--------------------------------

### Start ML Pipeline Workflow

Source: https://docs.temporal.io/guides/route-specialized-workloads.md

Example of initiating a workflow from a Temporal client to trigger resource-aware routing.

```python
# start_ml_pipeline.py
"""Start ML pipeline workflow with resource-aware routing."""
import asyncio
from temporalio.client import Client
from ml_pipeline_workflow import MLPipelineWorkflow, MLPipelineRequest

async def main():
    client = await Client.connect("localhost:7233")

    pipeline_request = MLPipelineRequest(
        pipeline_id="ml-pipeline-2024-001",
        dataset_url="s3://datasets/customer-behavior-10m.parquet",
        model_type="transformer",
        customer_id="customer-456",
    )

    handle = await client.start_workflow(
        MLPipelineWorkflow.run,
        pipeline_request,
        id=f"ml-pipeline-{pipeline_request.pipeline_id}",
        task_queue="workflows",
    )

    print(f"Started ML pipeline workflow: {handle.id}")

    # Wait for result (or use handle.describe() to check status)
    result = await handle.result()
    print(f"Pipeline completed: {result}")

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

--------------------------------

### Temporal Project Commands

Source: https://docs.temporal.io/ai-cookbook/ai-sdk-by-vercel-typescript.md

Common CLI commands for starting the Temporal server, installing dependencies, and executing the workflow.

```bash
temporal server start-dev
```

```bash
npm install
```

```bash
export OPENAI_API_KEY=<KEY>
```

```bash
npm run start.watch
```

```bash
npm run workflow
npm run workflow "What is the weather in Chicago?"
npm run workflow "Calculate the area of a circle with radius 5"
```

--------------------------------

### Initialize Test Environment

Source: https://docs.temporal.io/develop/go/best-practices/testing-suite.md

Implement SetupTest to create a new isolated test environment before each test execution.

```go
func (s *UnitTestSuite) SetupTest() {
    s.env = s.NewTestWorkflowEnvironment()
}
```

--------------------------------

### Run the Starter class

Source: https://docs.temporal.io/develop/java/set-up-your-local-java.md

Commands to execute the Starter class using Maven or Gradle build systems.

```bash
cd temporal-hello-world
mvn compile exec:java -Dexec.mainClass="helloworkflow.Starter"
```

```bash
./gradlew runStarter
```

--------------------------------

### Start and Configure Workflow Task Queues in Java

Source: https://docs.temporal.io/task-queue/naming.md

Examples of setting the task queue in WorkflowOptions and the worker factory.

```java
WorkflowOptions options = WorkflowOptions.newBuilder()
        .setWorkflowId("my-workflow")
        .setTaskQueue("my-task-queue-name")
        .build();

MyWorkflow workflow = client.newWorkflowStub(MyWorkflow.class, options);
```

```java
Worker worker = factory.newWorker("my-task-queue-name");
```

--------------------------------

### Install the Google ADK contrib module

Source: https://docs.temporal.io/develop/go/integrations/google-adk.md

Use the go get command to add the googleadk dependency to your project.

```bash
go get go.temporal.io/sdk/contrib/googleadk@latest
```

--------------------------------

### Initialize Temporal .NET project structure

Source: https://docs.temporal.io/develop/dotnet/set-up-your-local-dotnet.md

Creates a solution with Workflow, Worker, and Client projects, adds references, and installs the Temporalio package.

```bash
# Create solution and projects
mkdir TemporalioHelloWorld
cd TemporalioHelloWorld

dotnet new sln -n TemporalioHelloWorld

dotnet new classlib -o Workflow
dotnet new console -o Worker
dotnet new console -o Client

# Add projects to the solution
dotnet sln TemporalioHelloWorld.sln add Workflow/Workflow.csproj Worker/Worker.csproj Client/Client.csproj

# Add project references
dotnet add Worker/Worker.csproj reference Workflow/Workflow.csproj
dotnet add Client/Client.csproj reference Workflow/Workflow.csproj

# Install Temporal SDK in each project
dotnet add Workflow/Workflow.csproj package Temporalio
dotnet add Worker/Workflow.csproj package Temporalio
dotnet add Client/Client.csproj package Temporalio
```

--------------------------------

### Get a handle to an existing Standalone Activity

Source: https://docs.temporal.io/develop/python/activities/standalone-activities.md

Use client.get_activity_handle to reference a previously started activity by its ID and run ID.

```python
activity_handle = client.get_activity_handle(
    activity_id="my-standalone-activity-id",
    run_id="the-run-id",
)
```

--------------------------------

### Initialize a new PHP project

Source: https://docs.temporal.io/develop/php/set-up-your-local-php.md

Commands to create a project directory and initialize it with Composer.

```bash
mkdir temporal-hello-world
```

```bash
cd temporal-hello-world
```

```bash
composer init --name="myproject/quickstart" -n
```

--------------------------------

### Start Temporal server

Source: https://docs.temporal.io/ai-cookbook/hello-world-durable-mcp-server.md

Launch the local Temporal development server using the CLI.

```bash
# Using Temporal CLI
temporal server start-dev
```

--------------------------------

### Get a handle to an existing Standalone Activity

Source: https://docs.temporal.io/develop/go/activities/standalone-activities.md

Use GetActivityHandle to interact with a previously started Standalone Activity. Both ActivityID and RunID are required.

```go
handle := c.GetActivityHandle(client.GetActivityHandleOptions{
	ActivityID: "standalone_activity_helloworld_ActivityID",
	RunID:      "the-run-id",
})

// Use the handle to get the result, describe, cancel, or terminate
var result string
err := handle.Get(context.Background(), &result)
if err != nil {
	log.Fatalln("Unable to get activity result", err)
}
```

--------------------------------

### Create a new project

Source: https://docs.temporal.io/cli/command-reference/cloud/project.md

Initializes a new Temporal Cloud project with a display name and description.

```bash
temporal cloud project create --display-name "Engineering" --description "Engineering workloads"
```

--------------------------------

### Get a handle to an existing Standalone Activity

Source: https://docs.temporal.io/develop/dotnet/activities/standalone-activities.md

Use GetActivityHandle to reference a previously started activity by its ID and optional run ID.

```csharp
// Without a known result type
var handle = client.GetActivityHandle("my-activity-id", runId: "the-run-id");

// With a known result type
var typedHandle = client.GetActivityHandle<string>("my-activity-id", runId: "the-run-id");
```

--------------------------------

### Get a handle to an existing Standalone Activity

Source: https://docs.temporal.io/develop/typescript/activities/standalone-activities.md

Use getHandle to create a handle to a previously started Standalone Activity when the typed interface is unavailable.

```ts
const newHandle = client.activity.getHandle<string>(activityId);
```

--------------------------------

### Configure Global Cluster Settings

Source: https://docs.temporal.io/references/configuration.md

Provides a minimal configuration example for the global section, including membership broadcast address and Prometheus metrics setup.

```yaml
global:
  membership:
    broadcastAddress: '127.0.0.1'
  metrics:
    prometheus:
      framework: 'tally'
      listenAddress: '127.0.0.1:8000'
```

--------------------------------

### Start Temporal dev server with metrics

Source: https://docs.temporal.io/self-hosted-guide/monitoring.md

Launch the Temporal development server with the metrics port exposed.

```bash
temporal server start-dev --metrics-port 8000
```

--------------------------------

### Run Sample Worker and Starter

Source: https://docs.temporal.io/develop/dotnet/nexus/standalone-operations.md

Commands to execute the worker and starter components of the .NET Nexus sample.

```bash
TEMPORAL_NAMESPACE=my-handler-namespace dotnet run worker
```

```bash
TEMPORAL_NAMESPACE=my-caller-namespace dotnet run starter
```

--------------------------------

### Load Configuration from File

Source: https://docs.temporal.io/references/server-options.md

Specify a directory, environment, and zone to load server configuration.

```go
s, err := temporal.NewServer(
    temporal.WithConfigLoader(configDir, env, zone),
)
```

--------------------------------

### Get a handle to an existing Standalone Activity

Source: https://docs.temporal.io/develop/java/activities/standalone-activities.md

Use client.getHandle to create a typed handle to a previously started activity. Pass null as the run ID to target the latest run.

```java
ActivityHandle<String> handle =
    client.getHandle("standalone-activity-id", null, String.class);
```

--------------------------------

### Execute a Child Workflow and await completion

Source: https://docs.temporal.io/develop/typescript/workflows/child-workflows.md

Use executeChild to start a Child Workflow and wait for its completion. This example demonstrates running multiple child workflows concurrently using Promise.all.

```typescript
import { executeChild } from '@temporalio/workflow';

export async function parentWorkflow(...names: string[]): Promise<string> {
  const responseArray = await Promise.all(
    names.map((name) =>
      executeChild(childWorkflow, {
        args: [name],
        // workflowId, // add business-meaningful workflow id here
        // // regular workflow options apply here, with two additions (defaults shown):
        // cancellationType: ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED,
        // parentClosePolicy: ParentClosePolicy.PARENT_CLOSE_POLICY_TERMINATE
      }),
    ),
  );
  return responseArray.join('\n');
}
```

--------------------------------

### Install Temporal Proxy via Go

Source: https://docs.temporal.io/production-deployment/temporal-proxy.md

Use these commands to install the proxy binary from source. Pinning a specific version is recommended for production environments.

```bash
go install github.com/temporalio/temporal-proxy/cmd/proxy@latest
```

```bash
go install github.com/temporalio/temporal-proxy/cmd/proxy@vX.Y.Z
```

--------------------------------

### Implementing Client Call Interceptors

Source: https://docs.temporal.io/develop/python/workers/interceptors.md

Define a class inheriting from client.Interceptor and implement intercept_client to return an OutboundInterceptor. This example demonstrates context propagation by setting headers on outbound workflow starts.

```python
class ContextPropagationInterceptor(
    temporalio.client.Interceptor, temporalio.worker.Interceptor
):
    def __init__(
        self,
        payload_converter: temporalio.converter.PayloadConverter = temporalio.converter.default().payload_converter,
    ) -> None:
        self._payload_converter = payload_converter

    def intercept_client(
        self, next: temporalio.client.OutboundInterceptor
    ) -> temporalio.client.OutboundInterceptor:
        return _ContextPropagationClientOutboundInterceptor(
            next, self._payload_converter
        )

def set_header_from_context(
    input: _InputWithHeaders, payload_converter: temporalio.converter.PayloadConverter
) -> None:
    user_id_val = user_id.get()
    if user_id_val:
        input.headers = {
            **input.headers,
            HEADER_KEY: payload_converter.to_payload(user_id_val),
        }

class _ContextPropagationClientOutboundInterceptor(
    temporalio.client.OutboundInterceptor
):
    def __init__(
        self,
        next: temporalio.client.OutboundInterceptor,
        payload_converter: temporalio.converter.PayloadConverter,
    ) -> None:
        super().__init__(next)
        self._payload_converter = payload_converter

    async def start_workflow(
        self, input: temporalio.client.StartWorkflowInput
    ) -> temporalio.client.WorkflowHandle[Any, Any]:
        set_header_from_context(input, self._payload_converter)
        return await super().start_workflow(input)
```

--------------------------------

### Start Temporal Dev Server

Source: https://docs.temporal.io/ai-cookbook/human-in-the-loop-python.md

Launch the local Temporal development server.

```bash
temporal server start-dev
```

--------------------------------

### Build the .NET solution

Source: https://docs.temporal.io/develop/dotnet/set-up-your-local-dotnet.md

Compiles the initialized .NET solution.

```bash
dotnet build
```

--------------------------------

### Install Protobuf Dependency

Source: https://docs.temporal.io/develop/rust/quickstart.md

Install protobuf via Homebrew if dependency installation fails.

```bash
brew install protobuf
```

--------------------------------

### Initialize project directory

Source: https://docs.temporal.io/develop/python/set-up-your-local-python.md

Create and enter a new directory for the Temporal project.

```bash
mkdir temporal-project
```

```bash
cd temporal-project
```

--------------------------------

### Start an update with start

Source: https://docs.temporal.io/cli/command-reference/workflow.md

Sends an update to a workflow execution or starts a new one if it is not currently running. This command is currently experimental.

```bash
temporal workflow start-update-with-start \
  --update-name YourUpdate \
  --update-input '{"update-key": "update-value"}' \
```

--------------------------------

### Start Local Development Server

Source: https://docs.temporal.io/develop/dotnet/nexus/standalone-operations.md

Initialize the development server with specific namespaces required for testing Nexus operations.

```bash
./temporal server start-dev \
  --namespace my-caller-namespace \
  --namespace my-handler-namespace
```

--------------------------------

### Install dependencies

Source: https://docs.temporal.io/develop/ruby/set-up-local-ruby.md

Install all dependencies defined in the Gemfile.

```bash
bundle install
```

--------------------------------

### Initialize a new Temporal project

Source: https://docs.temporal.io/develop/typescript/set-up-your-local-typescript.md

Use the create command to scaffold a new project with the required SDK packages automatically.

```bash
npx @temporalio/create@latest ./my-app
```

--------------------------------

### Initiate Agent Workflow

Source: https://docs.temporal.io/ai-cookbook/agentic-loop-tool-call-claude-python.md

Demonstrates how to connect to a Temporal server and execute the agent workflow with a user query.

```python
import asyncio
import sys
import uuid

from temporalio.client import Client
from temporalio.contrib.pydantic import pydantic_data_converter

from workflows.agent import AgentWorkflow

async def main():
    client = await Client.connect(
        "localhost:7233",
        data_converter=pydantic_data_converter,
    )

    query = sys.argv[1] if len(sys.argv) > 1 else "Tell me about recursion"

    # Submit the agent workflow for execution
    result = await client.execute_workflow(
        AgentWorkflow.run,
        query,
        id=f"agentic-loop-claude-id-{uuid.uuid4()}",
        task_queue="tool-invoking-agent-claude-python-task-queue",
    )
    print(f"Result: {result}")

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

--------------------------------

### tcld migration start

Source: https://docs.temporal.io/cloud/tcld/migration.md

Starts a new migration process.

```APIDOC
## tcld migration start

### Description
Start a new migration.

### Parameters
- **--request-id** (string) - Optional - The request-id to use for the asynchronous operation (Alias: -r)
- **--endpoint-id** (string) - Required - Migration endpoint id (Alias: -e)
- **--source-namespace** (string) - Required - Source namespace name (Alias: -s)
- **--target-namespace** (string) - Required - Target namespace name (Alias: -t)
```

--------------------------------

### Raw Key Example

Source: https://docs.temporal.io/ai-cookbook/claim-check-pattern-python.md

Example of a raw key identifier.

```text
abc123-def4-5678-9abc-def012345678
```

--------------------------------

### Implement a Nexus Caller Starter in Go

Source: https://docs.temporal.io/develop/go/nexus/feature-guide.md

This starter program parses command-line flags for client configuration and executes multiple caller Workflows synchronously.

```go
package main

import (
	"context"
	"log"
	"os"
	"time"

	"go.temporal.io/sdk/client"

	"github.com/temporalio/samples-go/nexus/caller"
	"github.com/temporalio/samples-go/nexus/options"
	"github.com/temporalio/samples-go/nexus/service"
)

func main() {
	clientOptions, err := options.ParseClientOptionFlags(os.Args[1:])
	if err != nil {
		log.Fatalf("Invalid arguments: %v", err)
	}
	c, err := client.Dial(clientOptions)
	if err != nil {
		log.Fatalln("Unable to create client", err)
	}
	defer c.Close()
	runWorkflow(c, caller.EchoCallerWorkflow, "Nexus Echo 👋")
	runWorkflow(c, caller.HelloCallerWorkflow, "Nexus", service.ES)
}

func runWorkflow(c client.Client, workflow interface{}, args ...interface{}) {
	ctx := context.Background()
	workflowOptions := client.StartWorkflowOptions{
		ID:        "nexus_hello_caller_workflow_" + time.Now().Format("20060102150405"),
		TaskQueue: caller.TaskQueue,
	}

	wr, err := c.ExecuteWorkflow(ctx, workflowOptions, workflow, args...)
	if err != nil {
		log.Fatalln("Unable to execute workflow", err)
	}
	log.Println("Started workflow", "WorkflowID", wr.GetID(), "RunID", wr.GetRunID())

	// Synchronously wait for the workflow completion.
	var result string
	err = wr.Get(context.Background(), &result)
	if err != nil {
		log.Fatalln("Unable get workflow result", err)
	}
	log.Println("Workflow result:", result)
}
```

--------------------------------

### Start and Interact with Approval Workflow in Python

Source: https://docs.temporal.io/guides/reliable-document-approvals.md

Demonstrates how to connect to a Temporal client, start a workflow with search attributes, query status, send signals, and retrieve results.

```python
"""Client code to start a document approval Workflow and interact with it."""

from __future__ import annotations

import asyncio
import os

from temporalio.api.common.v1 import SearchAttributes
from temporalio.client import Client

from models import (
    ApprovalDecision,
    ApprovalStatus,
    ApproverConfig,
    DocumentSubmission,
)
from workflows import DocumentApprovalWorkflow

TASK_QUEUE = os.getenv("TEMPORAL_TASK_QUEUE", "document-approval")
NAMESPACE = os.getenv("TEMPORAL_NAMESPACE", "document-approval")

async def main() -> None:
    """Start an approval Workflow and demonstrate Signal and Query interactions."""
    client = await Client.connect("localhost:7233", namespace=NAMESPACE)

    document = DocumentSubmission(
        document_id="doc-2026-001",
        title="Q1 Budget Proposal",
        submitter_email="alice@example.com",
        submitter_name="Alice Chen",
        content_url="https://docs.example.com/q1-budget-v1",
        approver=ApproverConfig(
            approver_email="bob@example.com",
            approver_name="Bob Martinez",
            sla_seconds=172800,  # 48 hours
            escalation_email="carol@example.com",
            reminder_interval_seconds=86400,  # Remind every 24 hours
            max_reminders=3,  # Send max 3 reminders
        ),
    )

    workflow_id = f"approval-{document.document_id}"

    search_attributes = SearchAttributes.from_pairs([
        ("DocumentId", document.document_id),
        ("SubmitterEmail", document.submitter_email),
        ("ApprovalStatus", "SUBMITTED"),
    ])

    handle = await client.start_workflow(
        DocumentApprovalWorkflow.run,
        document,
        id=workflow_id,
        task_queue=TASK_QUEUE,
        search_attributes=search_attributes,
    )

    print(f"Workflow started: {workflow_id}")
    print(f"Run Id: {handle.result_run_id}")

    status = await handle.query(DocumentApprovalWorkflow.get_status)
    print(f"Current status: {status}")

    await handle.signal(
        DocumentApprovalWorkflow.submit_decision,
        ApprovalDecision(
            approver_email="bob@example.com",
            status=ApprovalStatus.APPROVED,
            comment="Budget looks good. Approved.",
        ),
    )
    print("Approval Signal sent")

    result = await handle.result()
    print(f"Workflow result: {result}")

    search_attributes = SearchAttributes.from_pairs([
        ("ApprovalStatus", result["status"].upper()),
    ])
    await client.update_workflow_search_attributes(workflow_id, search_attributes)

    # Query the audit trail
    audit_trail = await handle.query(
        DocumentApprovalWorkflow.get_audit_trail
    )
    print(f"Audit trail ({len(audit_trail)} entries):")
    for entry in audit_trail:
        print(f"  [{entry['timestamp']}] {entry['action']}: {entry['details']}")

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

--------------------------------

### tcld user get

Source: https://docs.temporal.io/cloud/tcld/user.md

Get information about a specific user.

```APIDOC
## tcld user get

### Description
Get user information.

### Parameters
#### Flags
- **--user-id** (string) - Optional - The user id (Alias: -id)
- **--user-email** (string) - Optional - The user email address of the user (Alias: -e)
```

--------------------------------

### Verify Rust Installation

Source: https://docs.temporal.io/develop/rust/quickstart.md

Check the installed version of the Rust compiler.

```bash
rustc --version
```

--------------------------------

### Implement Early Return in Go

Source: https://docs.temporal.io/design-patterns/early-return.md

Uses workflow.SetUpdateHandler and workflow.Await to signal initialization completion to the client.

```go
// workflow.go
func Workflow(ctx workflow.Context, txRequest TransactionRequest) (*Transaction, error) {
    var tx *Transaction
    var initDone bool
    var initErr error

    // Register update handler that waits for initialization
    workflow.SetUpdateHandler(ctx, UpdateName,
        func(ctx workflow.Context) (*Transaction, error) {
            workflow.Await(ctx, func() bool { return initDone })
            return tx, initErr
        },
    )

    // Phase 1: Fast synchronous initialization (local activity)
    localOpts := workflow.WithLocalActivityOptions(ctx, workflow.LocalActivityOptions{
        ScheduleToCloseTimeout: 5 * time.Second,
    })
    initErr = workflow.ExecuteLocalActivity(localOpts, txRequest.Init).Get(ctx, &tx)
    initDone = true // Signal update handler

    // Phase 2: Slow asynchronous completion
    activityCtx := workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
        StartToCloseTimeout: 30 * time.Second,
    })

    if initErr != nil {
        // Cancel on initialization failure
        return nil, workflow.ExecuteActivity(activityCtx, CancelTransaction, tx).Get(ctx, nil)
    }

    // Complete on initialization success
    return tx, workflow.ExecuteActivity(activityCtx, CompleteTransaction, tx).Get(ctx, nil)
}

// client.go
startOp := client.NewWithStartWorkflowOperation(
    client.StartWorkflowOptions{
        ID:                       "transaction-123",
        TaskQueue:                "transactions",
        WorkflowIDConflictPolicy: enumspb.WORKFLOW_ID_CONFLICT_POLICY_FAIL,
    },
    Workflow,
    txRequest,
)

updateHandle, err := client.UpdateWithStartWorkflow(ctx,
    client.UpdateWithStartWorkflowOptions{
        StartWorkflowOperation: startOp,
        UpdateOptions: client.UpdateWorkflowOptions{
            UpdateName:   UpdateName,
            WaitForStage: client.WorkflowUpdateStageCompleted,
        },
    },
)

// Get initialization result immediately
var tx Transaction
err = updateHandle.Get(ctx, &tx)
if err != nil {
    return err
}

// Use transaction ID immediately while workflow continues
fmt.Printf("Transaction initialized: %s\n", tx.ID)
```

--------------------------------

### Execute a Workflow

Source: https://docs.temporal.io/develop/python/set-up-your-local-python.md

Create a starter.py file to trigger the workflow execution, then run it from the terminal.

```python
import asyncio
import uuid
from temporalio.client import Client

async def main():
    client = await Client.connect("localhost:7233")
    result = await client.execute_workflow(
        "SayHelloWorkflow",
        "Temporal",
        id=f"say-hello-workflow-{uuid.uuid4()}",
        task_queue="my-task-queue",
    )
    print("Workflow result:", result)

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

```bash
source env/bin/activate
python3 starter.py
```

--------------------------------

### Verify PHP installation

Source: https://docs.temporal.io/develop/php/set-up-your-local-php.md

Check the currently installed version of PHP.

```bash
php -v
```

--------------------------------

### Start Temporal Services

Source: https://docs.temporal.io/guides/reliable-document-approvals.md

Commands to start the development server and the worker process.

```bash
temporal server start-dev
```

```bash
python worker.py
```

--------------------------------

### Load Default Client Options

Source: https://docs.temporal.io/develop/go/client/temporal-client.md

Creates a Temporal Client using default environment variables and configuration file settings.

```go
package main

import (
	"fmt"
	"log"

	"go.temporal.io/sdk/client"
	"go.temporal.io/sdk/contrib/envconfig"
)

func main() {
	// Loads the "default" profile from the standard location and environment variables.
	c, err := client.Dial(envconfig.MustLoadDefaultClientOptions())
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer c.Close()

	fmt.Printf("✅ Connected to Temporal namespace %q on %s\n", c.Options().Namespace, c.Options().HostPort)
}
```
Tokens:
Raw