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 informasi selengkapnya, lihat Teruskan argumen runtime dalam permintaan eksekusi.

Setelah eksekusi alur kerja selesai, histori dan hasilnya akan disimpan selama 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.

1. 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.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

6. Jika alur kerja mengakses resource Google Cloud lainnya, pastikan alur kerja tersebut dikaitkan dengan akun layanan yang memiliki izin yang benar untuk melakukannya. Untuk mempelajari akun layanan yang terkait dengan alur kerja yang ada, lihat Memverifikasi akun layanan terkait alur kerja.

   Perhatikan bahwa untuk membuat resource dan melampirkan akun layanan, Anda memerlukan izin untuk membuat resource tersebut dan meniru identitas akun layanan yang akan Anda lampirkan ke resource. Untuk mengetahui informasi selengkapnya, lihat Izin akun layanan.

7. Deploy alur kerja menggunakan konsol atau Google Cloud CLI.

Catatan: Untuk mengirim log ke Cloud Logging, pastikan akun layanan yang menjalankan alur kerja telah diberi peran yang mencakup 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

1. Untuk menjalankan alur kerja, di konsol Google Cloud , buka halaman Workflows:

   Buka Workflows

2. Di halaman Workflows, pilih alur kerja untuk membuka halaman detailnya.

3. Di halaman Workflow details, klik Execute.

4. Di halaman Execute workflow, di panel Input, Anda dapat memasukkan argumen runtime opsional untuk diteruskan ke alur kerja sebelum dieksekusi. Argumen harus dalam format JSON; misalnya, {"animal":"cat"}. Jika alur kerja Anda tidak menggunakan argumen runtime, kosongkan kolom ini.

5. Jika ingin, tentukan level logging panggilan yang ingin Anda terapkan ke eksekusi alur kerja. Dalam daftar Level log panggilan, pilih salah satu opsi berikut:

   • 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.

6. Klik Jalankan.

7. Di halaman Detail eksekusi, Anda dapat melihat hasil eksekusi, termasuk output, ID dan status eksekusi, serta langkah saat ini atau akhir dari eksekusi alur kerja. Untuk informasi selengkapnya, lihat Mengakses hasil eksekusi alur kerja.

   Catatan: Untuk mengakses halaman Detail eksekusi, 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 dan Mengelola akses.

gcloud

1. Buka terminal.

2. Temukan nama alur kerja yang ingin dieksekusi. Jika tidak mengetahui nama alur kerja, Anda dapat memasukkan perintah berikut untuk mencantumkan semua alur kerja:

   gcloud workflows list

3. Anda dapat menjalankan alur kerja menggunakan perintah gcloud workflows run atau perintah gcloud workflows execute:

   • 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.

4. Jika Anda menjalankan gcloud workflows execute, ID unik dari percobaan 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, output-nya akan mirip dengan berikut, dengan state yang menunjukkan keberhasilan alur kerja, dan status yang menentukan langkah alur kerja akhir dari 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.

1. Instal library klien dan siapkan lingkungan pengembangan Anda. Untuk mengetahui detailnya, lihat Ringkasan library klien Alur Kerja.

2. Clone repositori aplikasi contoh ke komputer lokal Anda:

   Java

   git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

   Atau, Anda dapat mendownload contoh dalam file ZIP dan mengekstraknya.

   Node.js

   git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

   Atau, Anda dapat mendownload contoh dalam file ZIP dan mengekstraknya.

   Python

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

   Atau, Anda dapat mendownload contoh dalam file ZIP dan mengekstraknya.

3. 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/

4. 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 ini melakukan hal berikut:

   1. Menyiapkan Library Klien Cloud untuk Alur Kerja.
   2. Menjalankan alur kerja.
   3. Melakukan polling terhadap eksekusi alur kerja (menggunakan backoff eksponensial) hingga eksekusi dihentikan.
   4. Mencetak hasil eksekusi.

5. 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

6. 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 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) kepada akun layanan agar akun tersebut memiliki izin untuk memicu eksekusi alur kerja Anda. Untuk informasi selengkapnya, lihat Memanggil Alur Kerja.

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 ditentukan pengguna untuk alur kerja—misalnya, myFirstWorkflow.
• PARAMETER: optional. Jika alur kerja yang Anda jalankan dapat menerima argumen runtime yang Anda teruskan sebagai bagian dari permintaan eksekusi, Anda dapat menambahkan string berformat JSON ke isi permintaan yang nilainya adalah satu atau beberapa pasangan nilai parameter yang di-escape—misalnya, "{\"searchTerm\":\"asia\"}".
• VALUE: optional. Nilai pasangan nilai parameter yang dapat diterima alur kerja Anda sebagai argumen runtime.
• CALL_LOGGING_LEVEL: optional. Tingkat logging panggilan yang akan diterapkan selama eksekusi. Secara default, tidak ada level logging yang ditentukan dan level log alur kerja akan diterapkan. Untuk mengetahui informasi selengkapnya, lihat Mengirim Log ke Logging. Salah satu dari 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 diutamakan daripada level log alur kerja.
  • LOG_ERRORS_ONLY: mencatat semua pengecualian yang tertangkap; atau saat panggilan dihentikan karena adanya pengecualian.
  • LOG_ALL_CALLS: mencatat semua panggilan ke sub-alur kerja atau fungsi library beserta hasilnya.
  • LOG_NONE: tidak ada logging panggilan.
• BACKLOG_EXECUTION: opsional. Jika ditetapkan ke true, eksekusi tidak akan ditunda saat kuota serentak habis. Untuk informasi selengkapnya, lihat Mengelola antrean eksekusi.

Meminta isi JSON:

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

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login , atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI . Anda dapat memeriksa akun yang saat ini aktif 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",
  "disableConcurrencyQuotaOverflowBuffering": "BACKLOG_EXECUTION"
}
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 gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login . Anda dapat memeriksa akun yang saat ini aktif 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",
  "disableConcurrencyQuotaOverflowBuffering": "BACKLOG_EXECUTION"
}
'@  | 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

API Explorer (browser)

Salin isi permintaan dan buka halaman referensi metode. Panel API Explorer terbuka di sisi kanan halaman. Anda bisa berinteraksi dengan alat ini untuk mengirim permintaan. Tempelkan isi permintaan di alat ini, lengkapi kolom lainnya yang wajib diisi, 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 dan 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 yang akan digunakan di perintah berikutnya.

• Untuk memeriksa status upaya eksekusi dan menunggu upaya selesai, masukkan perintah berikut:

  gcloud workflows executions wait EXECUTION_ID

  Ganti EXECUTION_ID dengan ID upaya eksekusi.

  Perintah menunggu upaya eksekusi selesai, lalu menampilkan hasilnya.

• Untuk menunggu hingga eksekusi terakhir selesai, lalu menampilkan hasil eksekusi yang selesai, masukkan perintah berikut:

  gcloud workflows executions wait-last

  Jika Anda 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 melakukan upaya eksekusi sebelumnya dalam sesi gcloud yang sama, perintah tersebut 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.
  

Filter eksekusi

Anda dapat menerapkan filter ke daftar eksekusi alur kerja yang ditampilkan oleh metode workflows.executions.list.

Anda dapat memfilter berdasarkan kolom berikut:

• createTime
• disableOverflowBuffering
• duration
• endTime
• executionId
• label
• startTime
• state
• stepName
• workflowRevisionId

Misalnya, untuk memfilter label (labels."fruit":"apple"), Anda dapat membuat permintaan API yang mirip dengan berikut ini:

GET https://workflowexecutions.googleapis.com/v1/projects/MY_PROJECT/locations/MY_LOCATION/workflows/MY_WORKFLOW/executions?view=full&filter=labels.%22fruit%22%3A%22apple%22"

Dengan keterangan:

• view=full menentukan tampilan yang menentukan kolom yang harus diisi dalam eksekusi yang ditampilkan; dalam hal ini, semua data
• labels.%22fruit%22%3A%22apple%22 adalah sintaksis filter yang dienkode ke URL

Untuk mengetahui informasi selengkapnya, lihat Pemfilteran AIP-160.

Mengelola backlog eksekusi

Pratinjau

Fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dalam Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Anda dapat menggunakan antrean eksekusi untuk menghindari percobaan ulang sisi klien, menghapus penundaan eksekusi, dan memaksimalkan throughput. Eksekusi yang tertunda akan otomatis berjalan begitu kuota konkurensi eksekusi tersedia.

Praktik terbaik: Jika menjalankan eksekusi alur kerja Anda dibatasi waktu atau sensitif, penundaan eksekusi tidak direkomendasikan, dan Anda harus mempertimbangkan untuk menonaktifkan fitur tersebut.

Ada jumlah maksimum eksekusi alur kerja aktif yang dapat berjalan secara serentak. Setelah kuota ini habis, dan jika penundaan eksekusi dinonaktifkan, atau jika kuota untuk eksekusi yang tertunda tercapai, eksekusi baru akan gagal dengan kode status HTTP 429 Too many requests. Dengan mengaktifkan antrean eksekusi, eksekusi baru akan berhasil dan dibuat dalam status QUEUED. Segera setelah kuota konkurensi eksekusi tersedia, eksekusi akan otomatis berjalan dan memasuki status ACTIVE.

Secara default, penundaan eksekusi diaktifkan untuk semua permintaan (termasuk yang dipicu oleh Cloud Tasks) dengan pengecualian berikut:

• Saat membuat eksekusi menggunakan konektor executions.run atau executions.create dalam alur kerja, penundaan eksekusi dinonaktifkan secara default. Anda dapat mengonfigurasinya dengan menetapkan kolom disableConcurrencyQuotaOverflowBuffering eksekusi secara eksplisit ke false.
• Untuk eksekusi yang dipicu oleh Pub/Sub, backlog eksekusi dinonaktifkan dan tidak dapat dikonfigurasi.

Perhatikan hal berikut:

• Eksekusi dalam antrean dimulai dalam urutan first-in-first-out (FIFO), berdasarkan upaya terbaik.
• Kolom stempel waktu createTime menunjukkan kapan eksekusi dibuat. Stempel waktu startTime menunjukkan kapan eksekusi otomatis muncul dari antrean backlog dan mulai berjalan. Untuk eksekusi yang tidak tertunda, kedua nilai stempel waktu tersebut sama.
• Batas untuk eksekusi yang tertunda dapat diamati menggunakan metrik kuota workflowexecutions.googleapis.com/executionbacklogentries. Untuk mengetahui informasi selengkapnya, lihat Melihat dan mengelola kuota.

Menonaktifkan backlogging eksekusi

Anda dapat menonaktifkan backlog eksekusi dengan menetapkan flag saat menggunakan Google Cloud CLI. Contoh:

gcloud workflows execute WORKFLOW_NAME
    --disable-concurrency-quota-overflow-buffering

Atau, Anda dapat menonaktifkan backlog eksekusi dengan menetapkan kolom disableConcurrencyQuotaOverflowBuffering ke true dalam isi JSON permintaan saat mengirim permintaan eksekusi ke Workflows REST API. Contoh:

{
  "argument": {"arg1":"value1"},
  "callLogLevel": "LOG_NONE",
  "disableConcurrencyQuotaOverflowBuffering": true
}

Untuk mengetahui informasi selengkapnya, lihat Menjalankan alur kerja.

Langkah selanjutnya

• Mengakses hasil eksekusi alur kerja
• Mengontrol urutan eksekusi dalam alur kerja
• Mengirim log eksekusi ke Cloud Logging
• Memperbarui alur kerja yang ada