Set up your dev environment with Go.

go version

go version go1.18.1 darwin/amd64

mkdir goproject

cd goproject

go mod init my-org/greeting

go get go.temporal.io/sdk

go get go.temporal.io/sdk/client

go mod tidy

brew install temporal

sudo mv temporal /usr/local/bin

temporal server start-dev

temporal server start-dev --ui-port 8080

Run Hello World: Test Your Installation​

Now let's verify your setup is working by creating and running a complete Temporal application with both a Workflow and Activity.

This test will confirm that:

• The Temporal Go SDK is properly installed
• Your local Temporal Service is running
• You can successfully create and execute Workflows and Activities
• The communication between components is functioning correctly

1. Create the Activity​

An Activity is a normal function or method that executes a single, well-defined action (either short- or long-running) that is typically prone to failure. Examples include any action that interacts with the outside world, such as sending emails, making network requests, writing to a database, or calling an API. If an Activity fails, Temporal automatically retries it based on your configuration.

Create an Activity file (activity.go):

package greeting

import (
    "context"
    "fmt"
)

func Greet(ctx context.Context, name string) (string, error) {
    return fmt.Sprintf("Hello %s", name), nil
}

2. Create the Workflow​

Workflows orchestrate Activities and contain the application logic. Temporal Workflows are resilient. They can run - and keep running - for years, even if the underlying infrastructure fails. If the application itself crashes, Temporal will automatically recreate its pre-failure state so it can continue right where it left off.

Create a Workflow file (workflow.go):

package greeting

import (
    "time"

    "go.temporal.io/sdk/workflow"
)

func SayHelloWorkflow(ctx workflow.Context, name string) (string, error) {
    ao := workflow.ActivityOptions{
        StartToCloseTimeout: time.Second * 10,
    }
    ctx = workflow.WithActivityOptions(ctx, ao)

    var result string
    err := workflow.ExecuteActivity(ctx, Greet, name).Get(ctx, &result)
    if err != nil {
        return "", err
    }

    return result, nil
}

3. Create and Run the Worker​

With your Activity and Workflow defined, you need a Worker to execute them. A Worker polls a Task Queue, that you configure it to poll, looking for work to do. Once the Worker dequeues a Workflow or Activity task from the Task Queue, it then executes that task.

Workers are a crucial part of your Temporal application as they're what actually execute the tasks defined in your Workflows and Activities. For more information on Workers, see Understanding Temporal and a deep dive into Workers.

Create a Worker file (worker/main.go):

package main

import (
    "log"

    "my-org/greeting"

    "go.temporal.io/sdk/client"
    "go.temporal.io/sdk/worker"
)

func main() {
    c, err := client.Dial(client.Options{})
    if err != nil {
        log.Fatalln("Unable to create client", err)
    }
    defer c.Close()

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

    w.RegisterWorkflow(greeting.SayHelloWorkflow)
    w.RegisterActivity(greeting.Greet)

    err = w.Run(worker.InterruptCh())
    if err != nil {
        log.Fatalln("Unable to start worker", err)
    }
}

Run the Worker:

go run worker/main.go

4. Execute the Workflow​

Now that your Worker is running, it's time to start a Workflow Execution.

Create a separate file called start/main.go:

package main

import (
    "context"
    "log"
    "os"

    greeting "my-org/greeting"

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

func main() {
    c, err := client.Dial(client.Options{})
    if err != nil {
        log.Fatalln("Unable to create client", err)
    }
    defer c.Close()

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

    we, err := c.ExecuteWorkflow(context.Background(), options, greeting.SayHelloWorkflow, os.Args[1])
    if err != nil {
        log.Fatalln("Unable to execute workflow", err)
    }
    log.Println("Started workflow", "WorkflowID", we.GetID(), "RunID", we.GetRunID())

    var result string
    err = we.Get(context.Background(), &result)
    if err != nil {
        log.Fatalln("Unable get workflow result", err)
    }
    log.Println("Workflow result:", result)
}

Then run:

go run start/main.go Temporal

Verify Success​

If everything is working correctly, you should see:

• Worker processing the workflow and activity
• Output: Workflow result: Hello Temporal
• Workflow Execution details in the Temporal Web UI