Menjalankan alur kerja

Mengeksekusi alur kerja akan menjalankan definisi alur kerja saat ini yang terkait dengan alur kerja.

Anda dapat meneruskan argumen runtime dalam permintaan eksekusi alur kerja dan mengakses argumen tersebut menggunakan variabel alur kerja. Untuk mengetahui informasi selengkapnya, lihat Meneruskan argumen runtime dalam permintaan eksekusi.

Setelah eksekusi alur kerja selesai, histori dan hasilnya akan disimpan untuk waktu terbatas. Untuk mengetahui informasi selengkapnya, lihat Kuota dan batas.

Sebelum memulai

Batasan keamanan yang ditentukan oleh organisasi mungkin mencegah Anda menyelesaikan langkah-langkah berikut. Untuk mengetahui informasi pemecahan masalah, lihat Mengembangkan aplikasi di lingkungan Google Cloud yang terbatas.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Make sure that billing is enabled for your Google Cloud project.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Make sure that billing is enabled for your Google Cloud project.

Jika alur kerja mengakses resource Google Cloud lainnya, pastikan resource tersebut dikaitkan dengan akun layanan yang memiliki izin yang tepat untuk melakukannya. Untuk mempelajari akun layanan mana yang terkait dengan alur kerja yang ada, lihat Memverifikasi akun layanan terkait alur kerja.
Perlu diperhatikan bahwa untuk membuat resource dan melampirkan akun layanan, Anda memerlukan izin untuk membuat resource tersebut dan meniru identitas akun layanan yang akan dikaitkan ke resource. Untuk informasi selengkapnya, lihat Izin akun layanan.
Deploy alur kerja menggunakan Google Cloud Console atau Google Cloud CLI.

Catatan: Untuk mengirim log ke Cloud Logging, pastikan akun layanan yang menjalankan alur kerja telah diberi peran yang menyertakan izin logging.logEntries.create (misalnya, peran Logs Writer).

Menjalankan alur kerja

Anda dapat menjalankan alur kerja menggunakan library klien, di Konsol Google Cloud, menggunakan gcloud CLI, atau dengan mengirim permintaan ke Workflows REST API.

Konsol

Untuk menjalankan alur kerja, di Konsol Google Cloud, buka halaman Workflows:

Buka Workflows
Di halaman Workflows, pilih alur kerja untuk membuka halaman detailnya.
Di halaman Workflow details, klik Execute.
Di halaman Execute Workflow, di panel Input, Anda dapat memasukkan argumen runtime opsional untuk diteruskan ke alur kerja Anda sebelum eksekusi. Argumen harus dalam format JSON; misalnya, {"animal":"cat"}. Jika alur kerja Anda tidak menggunakan argumen runtime, kosongkan kolom ini.
(Opsional) Tentukan level logging panggilan yang ingin Anda terapkan ke eksekusi alur kerja. Di daftar Level log panggilan, pilih salah satu dari:
- Tidak ditentukan: tidak ada level logging yang ditentukan. Ini adalah setelan defaultnya. Level log eksekusi lebih diutamakan daripada level log alur kerja apa pun, kecuali jika level log eksekusi tidak ditentukan (default); dalam hal ini, level log alur kerja berlaku.
- Hanya error: mencatat semua pengecualian yang tertangkap; atau saat panggilan dihentikan karena adanya suatu pengecualian.
- Semua panggilan: catat semua panggilan ke sub-alur kerja atau fungsi library beserta hasilnya.
- Tidak ada pencatatan: tidak ada logging panggilan.
Klik Jalankan.
Di halaman Execution details, Anda dapat melihat hasil eksekusi, termasuk output apa pun, ID dan status eksekusi, serta langkah saat ini atau terakhir dari eksekusi alur kerja. Untuk informasi selengkapnya, lihat Mengakses hasil eksekusi alur kerja.

Catatan: Untuk mengakses halaman Execution details, Anda harus memiliki peran yang berisi izin workflows.workflows.get, workflows.executions.get, dan workflows.stepEntries.list. Untuk mengetahui informasi selengkapnya, lihat Peran dan izin alur kerja serta Mengelola akses.

gcloud

Buka terminal.
Temukan nama alur kerja yang ingin Anda jalankan. Jika tidak tahu nama alur kerja, Anda dapat memasukkan perintah berikut untuk menampilkan daftar semua alur kerja:
```
gcloud workflows list
```
Anda dapat menjalankan alur kerja dengan dua cara:
- Jalankan alur kerja dan tunggu hingga eksekusi selesai:
```
gcloud workflows run WORKFLOW_NAME \
--call-log-level=CALL_LOGGING_LEVEL \
--data=DATA
```
- Jalankan alur kerja tanpa menunggu upaya eksekusi selesai:
```
gcloud workflows execute WORKFLOW_NAME \
--call-log-level=CALL_LOGGING_LEVEL \
--data=DATA
```
  Ganti kode berikut:
  - WORKFLOW_NAME: nama alur kerja.
  - CALL_LOGGING_LEVEL (opsional): level logging panggilan yang akan diterapkan selama eksekusi. Dapat berupa salah satu dari:
    - none: tidak ada level logging yang ditentukan. Ini adalah setelan defaultnya. Level log eksekusi lebih diutamakan daripada level log alur kerja apa pun, kecuali jika level log eksekusi tidak ditentukan (default); dalam hal ini, level log alur kerja berlaku.
    - log-errors-only: catat semua pengecualian yang tertangkap; atau saat panggilan dihentikan karena adanya pengecualian.
    - log-all-calls: catat semua panggilan ke sub-alur kerja atau fungsi library beserta hasilnya.
    - log-none: tidak ada logging panggilan.
  - DATA (opsional): argumen runtime untuk alur kerja Anda dalam format JSON.
Jika Anda menjalankan gcloud workflows execute, ID unik dari upaya eksekusi alur kerja akan ditampilkan dan outputnya mirip dengan berikut ini:
```
 To view the workflow status, you can use following command:
 gcloud workflows executions describe b113b589-8eff-4968-b830-8d35696f0b33 --workflow workflow-2 --location us-central1
```
Untuk melihat status eksekusi, masukkan perintah yang ditampilkan oleh langkah sebelumnya.

Jika upaya eksekusi berhasil, outputnya akan mirip dengan berikut ini, dengan state yang menunjukkan keberhasilan alur kerja, dan status yang menentukan langkah alur kerja akhir eksekusi.

argument: '{"searchTerm":"Friday"}'
endTime: '2022-06-22T12:17:53.086073678Z'
name: projects/1051295516635/locations/us-central1/workflows/myFirstWorkflow/executions/c4dffd1f-13db-46a0-8a4a-ee39c144cb96
result: '["Friday","Friday the 13th (franchise)","Friday Night Lights (TV series)","Friday
    the 13th (1980 film)","Friday the 13th","Friday the 13th (2009 film)","Friday the
    13th Part III","Friday the 13th Part 2","Friday (Rebecca Black song)","Friday Night
    Lights (film)"]'
startTime: '2022-06-22T12:17:52.799387653Z'
state: SUCCEEDED
status:
    currentSteps:
    - routine: main
        step: returnOutput
workflowRevisionId: 000001-ac2

Library klien

Contoh berikut mengasumsikan bahwa Anda telah men-deploy alur kerja, myFirstWorkflow.

Instal library klien dan siapkan lingkungan pengembangan Anda. Untuk mengetahui detailnya, lihat Ringkasan library klien alur kerja.
Clone repositori aplikasi contoh ke komputer lokal Anda:
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.

Ubah ke direktori yang berisi kode contoh Workflows:

Java

cd java-docs-samples/workflows/cloud-client/

Node.js

cd nodejs-docs-samples/workflows/quickstart/

Python

cd python-docs-samples/workflows/cloud-client/

Lihat kode contoh:

Java

// Imports the Google Cloud client library

import com.google.cloud.workflows.executions.v1.CreateExecutionRequest;
import com.google.cloud.workflows.executions.v1.Execution;
import com.google.cloud.workflows.executions.v1.ExecutionsClient;
import com.google.cloud.workflows.executions.v1.WorkflowName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class WorkflowsQuickstart {

  private static final String PROJECT = System.getenv("GOOGLE_CLOUD_PROJECT");
  private static final String LOCATION = System.getenv().getOrDefault("LOCATION", "us-central1");
  private static final String WORKFLOW =
      System.getenv().getOrDefault("WORKFLOW", "myFirstWorkflow");

  public static void main(String... args)
      throws IOException, InterruptedException, ExecutionException {
    if (PROJECT == null) {
      throw new IllegalArgumentException(
          "Environment variable 'GOOGLE_CLOUD_PROJECT' is required to run this quickstart.");
    }
    workflowsQuickstart(PROJECT, LOCATION, WORKFLOW);
  }

  private static volatile boolean finished;

  public static void workflowsQuickstart(String projectId, String location, String workflow)
      throws IOException, InterruptedException, ExecutionException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests. After completing all of your
    // requests, call the "close" method on the client to safely clean up any remaining background
    // resources.
    try (ExecutionsClient executionsClient = ExecutionsClient.create()) {
      // Construct the fully qualified location path.
      WorkflowName parent = WorkflowName.of(projectId, location, workflow);

      // Creates the execution object.
      CreateExecutionRequest request =
          CreateExecutionRequest.newBuilder()
              .setParent(parent.toString())
              .setExecution(Execution.newBuilder().build())
              .build();
      Execution response = executionsClient.createExecution(request);

      String executionName = response.getName();
      System.out.printf("Created execution: %s%n", executionName);

      long backoffTime = 0;
      long backoffDelay = 1_000; // Start wait with delay of 1,000 ms
      final long backoffTimeout = 10 * 60 * 1_000; // Time out at 10 minutes
      System.out.println("Poll for results...");

      // Wait for execution to finish, then print results.
      while (!finished && backoffTime < backoffTimeout) {
        Execution execution = executionsClient.getExecution(executionName);
        finished = execution.getState() != Execution.State.ACTIVE;

        // If we haven't seen the results yet, wait.
        if (!finished) {
          System.out.println("- Waiting for results");
          Thread.sleep(backoffDelay);
          backoffTime += backoffDelay;
          backoffDelay *= 2; // Double the delay to provide exponential backoff.
        } else {
          System.out.println("Execution finished with state: " + execution.getState().name());
          System.out.println("Execution results: " + execution.getResult());
        }
      }
    }
  }
}

Node.js (JavaScript)

const {ExecutionsClient} = require('@google-cloud/workflows');
const client = new ExecutionsClient();
/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const location = 'us-central1';
// const workflow = 'myFirstWorkflow';
// const searchTerm = '';

/**
 * Executes a Workflow and waits for the results with exponential backoff.
 * @param {string} projectId The Google Cloud Project containing the workflow
 * @param {string} location The workflow location
 * @param {string} workflow The workflow name
 * @param {string} searchTerm Optional search term to pass to the Workflow as a runtime argument
 */
async function executeWorkflow(projectId, location, workflow, searchTerm) {
  /**
   * Sleeps the process N number of milliseconds.
   * @param {Number} ms The number of milliseconds to sleep.
   */
  function sleep(ms) {
    return new Promise(resolve => {
      setTimeout(resolve, ms);
    });
  }
  const runtimeArgs = searchTerm ? {searchTerm: searchTerm} : {};
  // Execute workflow
  try {
    const createExecutionRes = await client.createExecution({
      parent: client.workflowPath(projectId, location, workflow),
      execution: {
        // Runtime arguments can be passed as a JSON string
        argument: JSON.stringify(runtimeArgs),
      },
    });
    const executionName = createExecutionRes[0].name;
    console.log(`Created execution: ${executionName}`);

    // Wait for execution to finish, then print results.
    let executionFinished = false;
    let backoffDelay = 1000; // Start wait with delay of 1,000 ms
    console.log('Poll every second for result...');
    while (!executionFinished) {
      const [execution] = await client.getExecution({
        name: executionName,
      });
      executionFinished = execution.state !== 'ACTIVE';

      // If we haven't seen the result yet, wait a second.
      if (!executionFinished) {
        console.log('- Waiting for results...');
        await sleep(backoffDelay);
        backoffDelay *= 2; // Double the delay to provide exponential backoff.
      } else {
        console.log(`Execution finished with state: ${execution.state}`);
        console.log(execution.result);
        return execution.result;
      }
    }
  } catch (e) {
    console.error(`Error executing workflow: ${e}`);
  }
}

executeWorkflow(projectId, location, workflowName, searchTerm).catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

Node.js (TypeScript)

import {ExecutionsClient} from '@google-cloud/workflows';
const client: ExecutionsClient = new ExecutionsClient();
/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const location = 'us-central1';
// const workflow = 'myFirstWorkflow';
// const searchTerm = '';

/**
 * Executes a Workflow and waits for the results with exponential backoff.
 * @param {string} projectId The Google Cloud Project containing the workflow
 * @param {string} location The workflow location
 * @param {string} workflow The workflow name
 * @param {string} searchTerm Optional search term to pass to the Workflow as a runtime argument
 */
async function executeWorkflow(
  projectId: string,
  location: string,
  workflow: string,
  searchTerm: string
) {
  /**
   * Sleeps the process N number of milliseconds.
   * @param {Number} ms The number of milliseconds to sleep.
   */
  function sleep(ms: number): Promise<unknown> {
    return new Promise(resolve => {
      setTimeout(resolve, ms);
    });
  }
  const runtimeArgs = searchTerm ? {searchTerm: searchTerm} : {};
  // Execute workflow
  try {
    const createExecutionRes = await client.createExecution({
      parent: client.workflowPath(projectId, location, workflow),
      execution: {
        // Runtime arguments can be passed as a JSON string
        argument: JSON.stringify(runtimeArgs),
      },
    });
    const executionName = createExecutionRes[0].name;
    console.log(`Created execution: ${executionName}`);

    // Wait for execution to finish, then print results.
    let executionFinished = false;
    let backoffDelay = 1000; // Start wait with delay of 1,000 ms
    console.log('Poll every second for result...');
    while (!executionFinished) {
      const [execution] = await client.getExecution({
        name: executionName,
      });
      executionFinished = execution.state !== 'ACTIVE';

      // If we haven't seen the result yet, wait a second.
      if (!executionFinished) {
        console.log('- Waiting for results...');
        await sleep(backoffDelay);
        backoffDelay *= 2; // Double the delay to provide exponential backoff.
      } else {
        console.log(`Execution finished with state: ${execution.state}`);
        console.log(execution.result);
        return execution.result;
      }
    }
  } catch (e) {
    console.error(`Error executing workflow: ${e}`);
  }
}

executeWorkflow(projectId, location, workflowName, searchTerm).catch(
  (err: Error) => {
    console.error(err.message);
    process.exitCode = 1;
  }
);

Python

import time

from google.cloud import workflows_v1
from google.cloud.workflows import executions_v1
from google.cloud.workflows.executions_v1 import Execution
from google.cloud.workflows.executions_v1.types import executions

def execute_workflow(
    project: str, location: str = "us-central1", workflow: str = "myFirstWorkflow"
) -> Execution:
    """Execute a workflow and print the execution results.

    A workflow consists of a series of steps described using the Workflows syntax, and can be written in either YAML or JSON.

    Args:
        project: The Google Cloud project id which contains the workflow to execute.
        location: The location for the workflow
        workflow: The ID of the workflow to execute.

    Returns:
        The execution response.
    """
    # Set up API clients.
    execution_client = executions_v1.ExecutionsClient()
    workflows_client = workflows_v1.WorkflowsClient()
    # Construct the fully qualified location path.
    parent = workflows_client.workflow_path(project, location, workflow)

    # Execute the workflow.
    response = execution_client.create_execution(request={"parent": parent})
    print(f"Created execution: {response.name}")

    # Wait for execution to finish, then print results.
    execution_finished = False
    backoff_delay = 1  # Start wait with delay of 1 second
    print("Poll for result...")
    while not execution_finished:
        execution = execution_client.get_execution(request={"name": response.name})
        execution_finished = execution.state != executions.Execution.State.ACTIVE

        # If we haven't seen the result yet, wait a second.
        if not execution_finished:
            print("- Waiting for results...")
            time.sleep(backoff_delay)
            # Double the delay to provide exponential backoff.
            backoff_delay *= 2
        else:
            print(f"Execution finished with state: {execution.state.name}")
            print(f"Execution results: {execution.result}")
            return execution

Contoh tersebut melakukan hal berikut:

Menyiapkan Library Klien Cloud untuk Workflows.
Menjalankan alur kerja.
Melakukan polling terhadap eksekusi alur kerja (menggunakan backoff eksponensial) hingga eksekusi dihentikan.
Mencetak hasil eksekusi.

Untuk menjalankan contoh, instal dependensi terlebih dahulu:
Java
```
mvn compile
```
Node.js (JavaScript)
```
npm install
```
Node.js (TypeScript)
```
npm install && npm run build
```
Python
```
pip3 install -r requirements.txt
```

Jalankan skrip:

Java

GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME mvn compile exec:java -Dexec.mainClass=com.example.workflows.WorkflowsQuickstart

Node.js (JavaScript)

npm start PROJECT_ID CLOUD_REGION WORKFLOW_NAME

Node.js (TypeScript)

npm start PROJECT_ID CLOUD_REGION WORKFLOW_NAME

Python

GOOGLE_CLOUD_PROJECT=PROJECT_ID LOCATION=CLOUD_REGION WORKFLOW=WORKFLOW_NAME python3 main.py

Ganti kode berikut:

PROJECT_ID (wajib): Project ID untuk project Google Cloud
CLOUD_REGION: lokasi untuk alur kerja (default: us-central1)
WORKFLOW_NAME: ID alur kerja (default: myFirstWorkflow)

Outputnya mirip dengan hal berikut ini:

Execution finished with state: SUCCEEDED
["Sunday","Sunday in the Park with George","Sunday shopping","Sunday Bloody Sunday","Sunday Times Golden Globe Race","Sunday All Stars","Sunday Night (South Korean TV series)","Sunday Silence","Sunday Without God","Sunday Independent (Ireland)"]

REST API

Untuk membuat eksekusi baru menggunakan revisi terbaru dari alur kerja tertentu, gunakan metode projects.locations.workflows.executions.create.

Perhatikan bahwa untuk mengautentikasi, Anda memerlukan akun layanan dengan hak istimewa yang memadai untuk menjalankan alur kerja. Misalnya, Anda dapat memberikan peran Workflows Invoker (roles/workflows.invoker) ke akun layanan, sehingga akun tersebut memiliki izin untuk memicu eksekusi alur kerja Anda. Untuk informasi selengkapnya, lihat Memanggil Workflows.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

PROJECT_NUMBER: nomor project Google Cloud Anda yang tercantum di halaman IAM & Admin Settings.
LOCATION: region tempat alur kerja di-deploy—misalnya, us-central1.
WORKFLOW_NAME: nama yang ditetapkan pengguna untuk alur kerja—misalnya, myFirstWorkflow.
PARAMETER: optional. Jika alur kerja yang dijalankan dapat menerima argumen runtime yang Anda teruskan sebagai bagian dari permintaan eksekusi, Anda dapat menambahkan string berformat JSON yang nilainya berupa satu atau beberapa pasangan parameter-value yang di-escape ke isi permintaan—misalnya, "{\"searchTerm\":\"asia\"}".
VALUE: optional. Nilai pasangan parameter value yang dapat diterima alur kerja Anda sebagai argumen runtime.
CALL_LOGGING_LEVEL: optional. Tingkat logging panggilan yang akan diterapkan selama eksekusi. Defaultnya adalah tidak ada level logging yang ditentukan dan level log alur kerjalah yang berlaku. Untuk mengetahui informasi lebih lanjut, lihat Mengirim Log ke Logging. Salah satu dari opsi berikut:
- CALL_LOG_LEVEL_UNSPECIFIED: tidak ada level logging yang ditentukan dan level log alur kerja yang berlaku. Ini adalah setelan defaultnya. Jika tidak, level log eksekusi akan berlaku dan lebih diprioritaskan daripada level log alur kerja.
- LOG_ERRORS_ONLY: mencatat semua pengecualian yang tertangkap; atau saat panggilan dihentikan karena suatu pengecualian.
- LOG_ALL_CALLS: mencatat semua panggilan ke sub-alur kerja atau fungsi library beserta hasilnya.
- LOG_NONE: tidak ada logging panggilan.

Meminta isi JSON:

{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL"
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke CLI gcloud dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login, atau menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke CLI gcloud. Anda dapat memeriksa akun yang aktif saat ini dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json. Jalankan perintah berikut di terminal untuk membuat atau menimpa file ini di direktori saat ini:

cat > request.json << 'EOF'
{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL"
}
EOF

Kemudian jalankan perintah berikut untuk mengirim permintaan REST Anda:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://workflowexecutions.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_NAME/executions"

PowerShell (Windows)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke CLI gcloud dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login. Anda dapat memeriksa akun yang aktif saat ini dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json. Jalankan perintah berikut di terminal untuk membuat atau menimpa file ini di direktori saat ini:

@'
{
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "callLogLevel": "CALL_LOGGING_LEVEL"
}
'@  | Out-File -FilePath request.json -Encoding utf8

Kemudian jalankan perintah berikut untuk mengirim permintaan REST Anda:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://workflowexecutions.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_NAME/executions" | Select-Object -Expand Content

APIs Explorer (browser)

Salin isi permintaan dan buka halaman referensi metode. Panel APIs Explorer akan terbuka di sisi kanan halaman. Anda bisa berinteraksi dengan alat ini untuk mengirim permintaan. Tempelkan isi permintaan di alat ini, lengkapi kolom wajib lainnya, lalu klik Jalankan.

Jika berhasil, isi respons akan memuat instance Execution yang baru dibuat:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/workflows/WORKFLOW_NAME/executions/EXECUTION_ID",
  "startTime": "2023-11-07T14:35:27.215337069Z",
  "state": "ACTIVE",
  "argument": "{\"PARAMETER\":\"VALUE\"}",
  "workflowRevisionId": "000001-2df",
  "callLogLevel": "CALL_LOGGING_LEVEL",
  "status": {}
}

Memeriksa status eksekusi

Ada beberapa perintah untuk membantu Anda memeriksa status eksekusi alur kerja.

Untuk mengambil daftar upaya eksekusi alur kerja beserta ID-nya, masukkan perintah berikut:
```
gcloud workflows executions list WORKFLOW_NAME
```
Ganti WORKFLOW_NAME dengan nama alur kerja.

Perintah ini menampilkan nilai NAME yang mirip dengan berikut ini:

projects/PROJECT_NUMBER/locations/REGION/workflows/WORKFLOW_NAME/executions/EXECUTION_ID

Salin ID eksekusi untuk digunakan di perintah berikutnya.
Untuk memeriksa status upaya eksekusi dan menunggu hingga upaya selesai, masukkan perintah berikut:
```
gcloud workflows executions wait EXECUTION_ID
```
Ganti EXECUTION_ID dengan ID upaya eksekusi.

Perintah tersebut menunggu upaya eksekusi selesai, lalu menampilkan hasilnya.
Untuk menunggu hingga eksekusi terakhir selesai lalu menampilkan hasil eksekusi yang telah selesai, masukkan perintah berikut:
```
gcloud workflows executions wait-last
```
Jika Anda telah melakukan upaya eksekusi sebelumnya dalam sesi gcloud yang sama, perintah akan menunggu hingga upaya eksekusi sebelumnya selesai, lalu menampilkan hasil eksekusi yang telah selesai. Jika tidak ada upaya sebelumnya, gcloud akan menampilkan error berikut:
```
ERROR: (gcloud.workflows.executions.wait-last) [NOT FOUND] There are no cached executions available.
```
Untuk mendapatkan status eksekusi terakhir, masukkan perintah berikut:
```
gcloud workflows executions describe-last
```
Jika Anda telah melakukan upaya eksekusi sebelumnya dalam sesi gcloud yang sama, perintah akan menampilkan hasil eksekusi terakhir meskipun sedang berjalan. Jika tidak ada upaya sebelumnya, gcloud akan menampilkan error berikut:
```
ERROR: (gcloud.beta.workflows.executions.describe-last) [NOT FOUND] There are no cached executions available.
```

Menjalankan alur kerja

Sebelum memulai

Menjalankan alur kerja

Konsol

gcloud

Library klien

Java

Node.js

Python

Java

Node.js

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

Java

Node.js (JavaScript)

Node.js (TypeScript)

Python

REST API

curl (Linux, macOS, atau Cloud Shell)

PowerShell (Windows)

APIs Explorer (browser)

Memeriksa status eksekusi

Langkah selanjutnya