Fix Cloud Run identity sample for renamed SDK module and trim docs

Author: seanbollin

gcp/cloud-run/workerid/Dockerfile

@@ -3,12 +3,7 @@ FROM eclipse-temurin:17-jdk-jammy AS build
 WORKDIR /workspace
 COPY . .
 
-# TEMPORARY (draft): this sample depends on io.temporal:temporal-gcp-cloud-run-worker-id, which is
-# not yet released to Maven Central. Until it ships, the Gradle build resolves it from a local
-# Temporal Java SDK checkout through a composite build (see README.md and settings.gradle). For an
-# image build the local SDK checkout must be available in the build context (or the module published
-# to Maven Local); once the module is released, bump javaSDKVersion in the samples root build.gradle
-# and this builds unchanged from Maven Central.
+# temporal-gcp-cloud-run-id is unreleased; the composite build resolves it from a local SDK checkout (see README).
 RUN ./gradlew --no-daemon :gcp:cloud-run:workerid:installDist
 
 FROM eclipse-temurin:17-jre-jammy

gcp/cloud-run/workerid/README.md

@@ -1,150 +1,60 @@
-# Temporal Cloud Run worker-identity worker
+# Temporal Cloud Run worker-identity sample
 
-This sample runs a continuously polling Temporal Java Worker in a Google Cloud Run **worker pool**.
-It registers the `WorkerIdPlugin` from the `temporal-gcp-cloud-run-worker-id` module on the Temporal
-client so the Worker's Temporal identity is derived from Cloud Run instance metadata as
-`{instanceId}@{revision}`. It registers a small greeting Workflow and Activity and runs until Cloud
-Run stops the instance. Identity only: the plugin sets the worker identity and nothing else.
+A continuously polling Temporal Java worker for a Google Cloud Run **worker pool** that registers
+`CloudRunIdPlugin` from `io.temporal:temporal-gcp-cloud-run-id` on the client, so the worker identity
+is derived from Cloud Run instance metadata as `{instanceId}@{revision}`. The plugin sets identity
+only. A small greeting workflow and activity run until Cloud Run stops the instance.
 
-Cloud Run runs a long-lived container rather than a per-request handler, so there is no function to
-wrap: registering the plugin on the client fetches the metadata once at startup and applies the
-derived identity to the client and the Workers created from it.
-
-> Experimental: Google Cloud Run support is experimental and may change without notice.
+> Google Cloud Run support is experimental and may change without notice.
 
 ## Unreleased SDK dependency
 
-This sample depends on `io.temporal:temporal-gcp-cloud-run-worker-id`, which is **not yet released**
-to Maven Central. Until it ships, the samples build wires the module from a local Temporal Java SDK
-checkout through a Gradle composite build (`includeBuild`), configured in the samples root
-`settings.gradle`.
-
-- It defaults to a sibling `../sdk-java-2` checkout on the `cloud-run-worker-id` branch.
-- Override the location with `-PtemporalSdkPath=/path/to/sdk-java`.
-- When that checkout is absent, the composite build is skipped and only this module is affected; the
-  other samples still build.
-
-Once `temporal-gcp-cloud-run-worker-id` is released, remove the composite-build block from
-`settings.gradle` and bump `javaSDKVersion` in the samples root `build.gradle` to the released
-version; the standard Maven Central build then works without the local checkout. This sample's pull
-request stays a draft until then.
-
-## Prerequisites
-
-- Java 17+
-- The Temporal CLI (to start Workflows)
-- The Google Cloud CLI (`gcloud`) with a project that has Cloud Run enabled
-- A Temporal Service reachable from Cloud Run. A plaintext connection is used by default; configure
-  TLS or an API key in `CloudRunWorker.java` for a secured Service such as Temporal Cloud.
-
-## Files
-
-- `src/main/java/io/temporal/samples/gcp/cloudrun/workerid/CloudRunWorker.java` fetches the Cloud
-  Run metadata, registers `WorkerIdPlugin` on the client to apply the derived identity, and runs a
-  long-lived Worker with a bounded shutdown on `SIGTERM`.
-- `GreetingWorkflow` / `GreetingWorkflowImpl` and `GreetingActivities` / `GreetingActivitiesImpl` are
-  the sample Workflow and Activity.
-- `Dockerfile` packages the Gradle application as the Worker container.
+`temporal-gcp-cloud-run-id` is not yet released. `settings.gradle` resolves it (and the other
+`io.temporal:*` modules) from a local SDK checkout via a Gradle composite build, defaulting to
+`../sdk-java` and overridable with `-PtemporalSdkPath`. CI has no checkout, so its build stays red
+until the module ships; then drop the composite block and bump `javaSDKVersion`.
 
 ## How it works
 
-Cloud Run **worker pools** set `CLOUD_RUN_WORKER_POOL` and `CLOUD_RUN_REVISION` on every instance
-(Cloud Run **services** set `K_SERVICE` and `K_REVISION`). `GoogleCloudRunMetadata.fetch()` resolves:
+Cloud Run worker pools set `CLOUD_RUN_WORKER_POOL` and `CLOUD_RUN_REVISION` (services set `K_SERVICE`
+and `K_REVISION`). `CloudRunIdPlugin` reads those plus the instance id from the Cloud Run metadata
+server and sets the client identity to `{instanceId}@{revision}` unless one is already set; workers
+created from the client inherit it. `GoogleCloudRunMetadata.fetch().identity()` exposes the same
+value, which the worker logs at startup.
 
-- **name**: the first non-empty of `CLOUD_RUN_WORKER_POOL` then `K_SERVICE`.
-- **revision**: the first non-empty of `CLOUD_RUN_REVISION` then `K_REVISION`.
-- **instance id**: a single HTTP `GET` to the Cloud Run metadata server
-  (`http://metadata.google.internal/computeMetadata/v1/instance/id`, header `Metadata-Flavor:
-  Google`).
+The worker reads `TEMPORAL_ADDRESS` (default `127.0.0.1:7233`), `TEMPORAL_NAMESPACE` (default
+`default`), and `TEMPORAL_TASK_QUEUE` (default `cloud-run-worker-id`). A plaintext connection is used;
+configure TLS or an API key in `CloudRunWorker.java` for a secured Service such as Temporal Cloud.
 
-`WorkerIdPlugin`, registered on the client with `WorkflowClientOptions.Builder.setPlugins(...)`, then
-sets the Worker identity to `{instanceId}@{revision}` (falling back to `{instanceId}@{name}` and then
-`{instanceId}`) unless an identity is already set. Workers created from the client inherit that
-identity; the plugin sets nothing else on them.
-
-The Worker reads its connection settings from the environment:
-
-```bash
-TEMPORAL_ADDRESS     # host:port of the Temporal frontend (default 127.0.0.1:7233)
-TEMPORAL_NAMESPACE   # Temporal Namespace (default "default")
-TEMPORAL_TASK_QUEUE  # Task Queue to poll (default "cloud-run-worker-id")
-```
-
-`CLOUD_RUN_WORKER_POOL` and `CLOUD_RUN_REVISION` are injected by Cloud Run and do not need to be set
-manually.
-
-## Build and test locally
-
-The unit test uses `TestWorkflowRule` and needs neither Cloud Run nor a running Temporal Service:
+## Build and test
 
 ```bash
 ./gradlew :gcp:cloud-run:workerid:test
-```
-
-Build the runnable application (from a local SDK checkout, per the note above):
-
-```bash
 ./gradlew -PtemporalSdkPath=/path/to/sdk-java :gcp:cloud-run:workerid:installDist
 ```
 
-## Deploy to a Cloud Run worker pool
+## Deploy
 
-Worker pools keep CPU allocated so the Temporal Worker can poll continuously; they are not
-request-driven Cloud Run services. Set your connection values and deploy from the sample directory:
+Worker pools keep CPU allocated for continuous polling. Until `temporal-gcp-cloud-run-id` is released
+a remote `--source` build cannot resolve it, so build the image locally against your SDK checkout and
+deploy it by tag:
 
 ```bash
 export REGION=us-central1
-export TEMPORAL_ADDRESS=<your-namespace>.<account>.tmprl.cloud:7233
-export TEMPORAL_NAMESPACE=<your-namespace>.<account>
-export TEMPORAL_TASK_QUEUE=cloud-run-worker-id
-
-gcloud run worker-pools deploy cloud-run-worker-id \
-  --source . \
-  --region "$REGION" \
-  --set-env-vars "TEMPORAL_ADDRESS=$TEMPORAL_ADDRESS,TEMPORAL_NAMESPACE=$TEMPORAL_NAMESPACE,TEMPORAL_TASK_QUEUE=$TEMPORAL_TASK_QUEUE"
-```
-
-`--source .` builds the container from the included `Dockerfile`. Because the image build resolves
-the unreleased `temporal-gcp-cloud-run-worker-id` module, a remote source build succeeds only once
-that module is released (or published to your Maven Local and made available to the build). Until
-then, build the image locally against your SDK checkout and deploy it with `--image` instead:
-
-```bash
 gcloud run worker-pools deploy cloud-run-worker-id \
   --image "$REGION-docker.pkg.dev/$PROJECT_ID/<repo>/cloud-run-worker-id:latest" \
   --region "$REGION" \
-  --set-env-vars "TEMPORAL_ADDRESS=$TEMPORAL_ADDRESS,TEMPORAL_NAMESPACE=$TEMPORAL_NAMESPACE,TEMPORAL_TASK_QUEUE=$TEMPORAL_TASK_QUEUE"
+  --set-env-vars "TEMPORAL_ADDRESS=<addr>,TEMPORAL_NAMESPACE=<ns>,TEMPORAL_TASK_QUEUE=cloud-run-worker-id"
 ```
 
-Each Cloud Run revision starts a fresh instance whose Worker reports a distinct identity, which the
-Worker logs at startup.
+Each revision starts a fresh instance whose worker reports a distinct identity.
 
-## Start a Workflow
-
-After the Worker is polling, start the sample Workflow on the same Task Queue:
+## Start a workflow
 
 ```bash
-temporal workflow start \
-  --task-queue cloud-run-worker-id \
-  --type GreetingWorkflow \
-  --workflow-id cloud-run-greeting \
-  --input '"Cloud Run"'
+temporal workflow start --type GreetingWorkflow --task-queue cloud-run-worker-id \
+  --workflow-id cloud-run-greeting --input '"Cloud Run"'
 ```
 
-The Worker's identity appears on its Task Queue pollers (for example in `temporal task-queue
-describe`) and on the events it records.
-
-## Shutdown
-
-Cloud Run sends `SIGTERM` and allows a short grace period before `SIGKILL`. The shutdown hook stops
-polling, waits up to six seconds for in-flight tasks to drain, escalates to a forced shutdown if
-needed, and then closes the service connection. Long-running Activities should still heartbeat and
-handle cancellation so they can stop within the platform's shutdown window.
-
-## Clean up
-
-Delete the worker pool when you are done:
-
-```bash
-gcloud run worker-pools delete cloud-run-worker-id --region "$REGION"
-```
+The identity appears on the task-queue pollers (`temporal task-queue describe`) and recorded events.
+Delete the pool with `gcloud run worker-pools delete cloud-run-worker-id --region "$REGION"`.

gcp/cloud-run/workerid/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'application'
 
 dependencies {
     implementation "io.temporal:temporal-sdk:$javaSDKVersion"
-    implementation "io.temporal:temporal-gcp-cloud-run-worker-id:$javaSDKVersion"
+    implementation "io.temporal:temporal-gcp-cloud-run-id:$javaSDKVersion"
     runtimeOnly group: 'ch.qos.logback', name: 'logback-classic', version: '1.5.6'
 
     testImplementation "io.temporal:temporal-testing:$javaSDKVersion"
@@ -18,7 +18,6 @@ dependencies {
 
 application {
     mainClass = 'io.temporal.samples.gcp.cloudrun.workerid.CloudRunWorker'
-    // Keep a stable launcher/installDist name independent of the nested Gradle
-    // project name (:gcp:cloud-run:workerid), which the Dockerfile relies on.
+    // Stable launcher name the Dockerfile relies on, independent of the Gradle project path.
     applicationName = 'cloud-run-worker-id'
 }

gcp/cloud-run/workerid/src/main/java/io/temporal/samples/gcp/cloudrun/workerid/CloudRunWorker.java

@@ -2,8 +2,8 @@
 
 import io.temporal.client.WorkflowClient;
 import io.temporal.client.WorkflowClientOptions;
-import io.temporal.gcp.cloudrun.workerid.GoogleCloudRunMetadata;
-import io.temporal.gcp.cloudrun.workerid.WorkerIdPlugin;
+import io.temporal.gcp.cloudrun.id.CloudRunIdPlugin;
+import io.temporal.gcp.cloudrun.id.GoogleCloudRunMetadata;
 import io.temporal.serviceclient.WorkflowServiceStubs;
 import io.temporal.serviceclient.WorkflowServiceStubsOptions;
 import io.temporal.worker.Worker;
@@ -27,30 +27,22 @@ public final class CloudRunWorker {
   private CloudRunWorker() {}
 
   public static void main(String[] args) {
-    // Read Cloud Run instance metadata once during startup. This performs a single HTTP request to
-    // the Cloud Run metadata server and throws IllegalStateException when it is unreachable, which
-    // usually means the process is not running on Google Cloud Run.
-    GoogleCloudRunMetadata metadata = GoogleCloudRunMetadata.fetch();
-
     String address = envOrDefault(ADDRESS_ENV, DEFAULT_ADDRESS);
     String namespace = envOrDefault(NAMESPACE_ENV, DEFAULT_NAMESPACE);
     String taskQueue = envOrDefault(TASK_QUEUE_ENV, DEFAULT_TASK_QUEUE);
 
-    // Plaintext connection to the Temporal Service. Configure TLS or an API key here for a secured
-    // Service such as Temporal Cloud.
+    // Plaintext connection; add TLS or an API key here for Temporal Cloud.
     WorkflowServiceStubs service =
         WorkflowServiceStubs.newServiceStubs(
             WorkflowServiceStubsOptions.newBuilder().setTarget(address).build());
 
-    // Register WorkerIdPlugin on the client. It sets the derived worker identity
-    // ({instanceId}@{revision}) on the client, and workers created from the client inherit it.
-    // Passing the already-fetched metadata avoids a second call to the Cloud Run metadata server.
+    // CloudRunIdPlugin sets the client identity to {instanceId}@{revision} from metadata.
     WorkflowClient client =
         WorkflowClient.newInstance(
             service,
             WorkflowClientOptions.newBuilder()
                 .setNamespace(namespace)
-                .setPlugins(new WorkerIdPlugin(metadata))
+                .setPlugins(new CloudRunIdPlugin())
                 .build());
 
     WorkerFactory factory = WorkerFactory.newInstance(client);
@@ -65,16 +57,15 @@ public static void main(String[] args) {
     factory.start();
     logger.info(
         "Temporal worker started (identity={}, taskQueue={})",
-        metadata.workerIdentity(),
+        GoogleCloudRunMetadata.fetch().identity(),
         taskQueue);
 
     // Cloud Run worker pools are continuous workloads, so keep the process alive until SIGTERM.
     factory.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
   }
 
   private static void shutdown(WorkerFactory factory, WorkflowServiceStubs service) {
-    // Cloud Run sends SIGTERM and allows a short grace period before SIGKILL. Stop polling, drain
-    // in-flight tasks, then close the service connection.
+    // Cloud Run sends SIGTERM before SIGKILL; stop polling, drain in-flight tasks, then close.
     factory.shutdown();
     factory.awaitTermination(6, TimeUnit.SECONDS);
     if (!factory.isTerminated()) {

gcp/cloud-run/workerid/src/main/java/io/temporal/samples/gcp/cloudrun/workerid/GreetingActivities.java

@@ -1,12 +1,8 @@
 package io.temporal.samples.gcp.cloudrun.workerid;
 
 import io.temporal.activity.ActivityInterface;
-import io.temporal.activity.ActivityMethod;
 
-/** Activity interface used by {@link GreetingWorkflow}. */
 @ActivityInterface
 public interface GreetingActivities {
-
-  @ActivityMethod
   String composeGreeting(String name);
 }

gcp/cloud-run/workerid/src/main/java/io/temporal/samples/gcp/cloudrun/workerid/GreetingActivitiesImpl.java

@@ -3,7 +3,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-/** Activity implementation that returns a simple greeting. */
 public final class GreetingActivitiesImpl implements GreetingActivities {
 
   private static final Logger logger = LoggerFactory.getLogger(GreetingActivitiesImpl.class);

gcp/cloud-run/workerid/src/main/java/io/temporal/samples/gcp/cloudrun/workerid/GreetingWorkflow.java

@@ -3,10 +3,8 @@
 import io.temporal.workflow.WorkflowInterface;
 import io.temporal.workflow.WorkflowMethod;
 
-/** A small greeting workflow run by the Cloud Run worker. */
 @WorkflowInterface
 public interface GreetingWorkflow {
-
   @WorkflowMethod
   String getGreeting(String name);
 }

gcp/cloud-run/workerid/src/main/java/io/temporal/samples/gcp/cloudrun/workerid/GreetingWorkflowImpl.java

@@ -4,9 +4,7 @@
 import io.temporal.workflow.Workflow;
 import java.time.Duration;
 
-/** Greeting workflow implementation. */
 public final class GreetingWorkflowImpl implements GreetingWorkflow {
-
   private final GreetingActivities activities =
       Workflow.newActivityStub(
           GreetingActivities.class,

gcp/cloud-run/workerid/src/test/java/io/temporal/samples/gcp/cloudrun/workerid/GreetingWorkflowTest.java

@@ -7,9 +7,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 
-/** Unit test for the sample Workflow and Activity. */
 public class GreetingWorkflowTest {
-
   @Rule
   public TestWorkflowRule testWorkflowRule =
       TestWorkflowRule.newBuilder()

settings.gradle

@@ -11,18 +11,8 @@ include 'lambda-worker:starter'
 include 'lambda-worker:worker'
 include 'gcp:cloud-run:workerid'
 
-// TEMPORARY (draft): the gcp:cloud-run:workerid sample depends on
-// io.temporal:temporal-gcp-cloud-run-worker-id (and the worker-identity APIs it builds on), which
-// are not yet released to Maven Central. Until they ship, wire the sample against a local Temporal
-// Java SDK checkout with a Gradle composite build so it can compile and run. Defaults to a sibling
-// ../sdk-java-2 checkout on the cloud-run-worker-id branch; override the location with
-// -PtemporalSdkPath=/path/to/sdk-java. When the checkout is absent (for example on CI building the
-// other samples) the composite build is skipped and only the gcp:cloud-run:workerid module is
-// affected. Remove this block and bump javaSDKVersion in build.gradle once
-// temporal-gcp-cloud-run-worker-id is released.
-def temporalSdkPath = gradle.startParameter.projectProperties['temporalSdkPath'] ?: '../sdk-java-2'
-def temporalSdkFile = new File(temporalSdkPath)
-def temporalSdkDir = temporalSdkFile.isAbsolute() ? temporalSdkFile : new File(settingsDir, temporalSdkPath)
-if (temporalSdkDir.isDirectory()) {
+// The gcp:cloud-run samples use unreleased temporal-gcp-cloud-run-* modules; resolve them from a local SDK checkout (default ../sdk-java, override with -PtemporalSdkPath) via composite build.
+def temporalSdkPath = gradle.startParameter.projectProperties['temporalSdkPath'] ?: '../sdk-java'
+if (file(temporalSdkPath).isDirectory()) {
     includeBuild temporalSdkPath
 }