[Yandex Cloud documentation](../../index.md) > [Tutorials](../index.md) > [Serverless technologies](index.md) > Serverless-based workflows and automation > Setting up Workflows integration with Tracker, YandexGPT, and Yandex Cloud Postbox

# Configuring Workflows integrated with Yandex Tracker, Yandex Cloud AI Studio, and Yandex Cloud Postbox


{% note info %}

Workflows is at the [Preview](../../overview/concepts/launch-stages.md) stage.

{% endnote %}

In this tutorial, you will create [workflows](../../serverless-integrations/concepts/workflows/workflow.md) in Yandex Workflows and configure their integration with [Yandex Tracker](https://yandex.ru/support/tracker/ru), [Yandex Cloud AI Studio](https://aistudio.yandex.ru/docs/en/ai-studio/concepts/generation/index), and [Yandex Cloud Postbox](../../postbox/index.md).

Your workflows will receive information about the issues in a given Tracker [queue](https://yandex.ru/support/tracker/ruabout-tracker#ochered) and use YandexGPT Pro to analyze the work completed within these issues, their statuses, and evaluation. The results of the analysis and a brief progress report will be saved in a comment to one of the Tracker issues and also sent to the specified email address via Yandex Cloud Postbox.

To configure a workflow in Yandex Workflows:

1. [Get your cloud ready](#before-you-begin).
1. [Create a service account](#service-account).
1. [Set up Tracker](#prepare-tracker).
1. [Configure workflow access in Tracker](#setup-tracker-access).
1. [Create an address and verify domain ownership in Yandex Cloud Postbox](#setup-postbox).
1. [Create a Workflows workflow](#setup-workflow).
1. [Test the workflow](#test).

If you no longer need the resources you created, [delete them](#clear-out).

## Getting started {#before-you-begin}

1. [Log in](https://passport.yandex.com/auth) to your Yandex account. If you do not have an account, [create](https://yandex.com/support/passport/authorization/registration.html) one.
1. Sign up for Yandex Cloud and create a [billing account](../../billing/concepts/billing-account.md):
    1. Navigate to the [management console](https://console.yandex.cloud) and log in to Yandex Cloud or create a new account.
    1. On the **[Yandex Cloud Billing](https://center.yandex.cloud/billing/accounts)** page, make sure you have a billing account linked and it has the `ACTIVE` or `TRIAL_ACTIVE` [status](../../billing/concepts/billing-account-statuses.md). If you do not have a billing account, [create one](../../billing/quickstart/index.md) and [link](../../billing/operations/pin-cloud.md) a cloud to it.

    If you have an active billing account, you can create or select a [folder](../../resource-manager/concepts/resources-hierarchy.md#folder) for your infrastructure on the [cloud page](https://console.yandex.cloud/cloud).

    [Learn more about clouds and folders here](../../resource-manager/concepts/resources-hierarchy.md).
1. Install [cURL](https://curl.haxx.se), as you will need it to send a request for a Yandex ID application OAuth token.

### Required paid resources {#paid-resources}

The cost of support for the new infrastructure includes:

* Fee for storing the [secret](../../lockbox/concepts/secret.md) and requests to the secret (see [Yandex Lockbox pricing](../../lockbox/pricing.md)).
* Fee for using Yandex Cloud AI Studio (see [Yandex Cloud AI Studio pricing](https://aistudio.yandex.ru/docs/en/ai-studio/pricing)).
* Fee for using Yandex Tracker (see [Tracker pricing](https://yandex.ru/support/tracker/rupricing)).
* Fee for using Yandex Cloud Postbox (see [Yandex Cloud Postbox pricing](../../postbox/pricing.md)).

## Create a service account {#service-account}

{% list tabs group=instructions %}

- Management console {#console}

  1. In the [management console](https://console.yandex.cloud), select the folder where you are going to create your workflows.
  1. Navigate to **Identity and Access Management**.
  1. Click **Create service account**, and in the window that opens:
      1. Name the [service account](../../iam/concepts/users/service-accounts.md): `workflow-sa`.
      1. Click ![image](../../_assets/console-icons/plus.svg) **Add role** and select [`serverless.workflows.executor`](../../iam/concepts/access-control/roles.md).
      1. Repeat the previous step to add the [`postbox.sender`](../../postbox/security/index.md#postbox-sender) and [`ai.languageModels.user`](https://aistudio.yandex.ru/docs/en/ai-studio/security/index#languageModels-user) roles.
      1. Click **Create**.

{% endlist %}

## Set up a queue and issues in Tracker {#prepare-tracker}

To make sure the workflows you create in this tutorial work properly, set up a queue in Yandex Tracker.

{% list tabs group=instructions %}

- Tracker UI {#console}

  1. If Yandex Tracker is not enabled in your organization, [enable](https://yandex.ru/support/tracker/ruenable-tracker) it.
  1. If you do not have a queue in Tracker yet, [create](https://yandex.ru/support/tracker/rumanager/create-queue) one.
  1. [Create](https://yandex.ru/support/tracker/ruuser/create-ticket) 5–10 test issues in your queue that meet the following requirements:

      * The test issues must be created in one queue.
      * All test issues must have the `product` [tag](https://yandex.ru/support/tracker/ruglossary#rus-t) set in the **Tags** field.
      * All test issues must be evaluated in [Story Points](https://yandex.ru/support/tracker/ruglossary#en-s) in the **Story Points** field.
      * Some of the test issues must be in the `Closed` [status](https://yandex.ru/support/tracker/ruabout-tracker#process), and some, in the `Open` status.
      * Closed test issues must include [comments](https://yandex.ru/support/tracker/ruuser/comments) on your work progress.

{% endlist %}

## Configure access for workflow authentication in Tracker {#setup-tracker-access}

To authenticate your workflow in Yandex Tracker, get a token of an [OAuth application](https://yandex.ru/dev/id/doc/ru/concepts/ya-oauth-intro) with read and write permissions for Tracker.

### Create an OAuth application in Yandex ID {#create-app}

To create an OAuth application with read and write access permissions for Tracker:

1. In your browser, go to the [OAuth application creation page](https://oauth.yandex.com/client/new/). On the page that opens:
    1. In the **Service name** field, enter the name of the OAuth application you are creating: `My Tracker Workflow`.
    1. Under **Application platforms**, select the **Web services** option and specify the redirect URI in the field that appears: `https://oauth.yandex.com/verification_code`.
    1. Under **Data access**, in the **Access name** field, enter `tracker:read` and select `Read from tracker`. 

        The `Read from tracker` option will appear below, in the application access list.

        Similarly, add the `tracker:write` access (`Write to tracker`).
    1. Under **Email for communication**, specify your email address to send notifications about the new application.
    1. Click **Create app**.

On the new application's page, copy the **ClientID** and **Client secret** field values. You will need them in the next step to get an OAuth token.

### Get the application's OAuth token {#create-token}

1. [Get](https://yandex.ru/dev/id/doc/ru/codes/code-url#code) the confirmation code. To do this, paste the following address into your browser address bar, replacing the `client_id` value with the one copied in the previous step:

    ```text
    https://oauth.yandex.ru/authorize?response_type=code&client_id=<ClientID_value>
    ```

    Confirm granting your OAuth application access to Tracker.

    In the window that opens, copy and save the confirmation code you get. You will need this code to get an OAuth token.
1. Get the application's OAuth token by running this command in the terminal:

    ```bash
    curl \
      --request POST \
      --header "Content-type: application/x-www-form-urlencoded" \
      --data "grant_type=authorization_code&code=<confirmation_code>&client_id=<ClientID_value>&client_secret=<Client_secret_value>" \
      https://oauth.yandex.ru/token
    ```

    Where:
    * `code`: Confirmation code you got in the previous step.
    * `client_id`: Your OAuth application's **ClientID** value you got earlier.
    * `client_secret`: Your OAuth application's **Client secret** value you got earlier.

    Result:

    ```json
    {"access_token": "y0__wgBhMmiugUY4b40IJCda4YSeAfV5tAoPqy2tttkQsy********", "expires_in": 31536000, "refresh_token": "1:7WGrfpErRSTlkTJI:NGU-BJxhvhUdwDxDuez5ana4Befm63bXXhNpJFnbWDX1XJ_rJ3qh6DH_AItBhFJk********:ZZP-Pf0nxo4nil********", "token_type": "bearer"}%
    ```

    Store the value returned in the `access_token` field. This is the application's OAuth token the workflow will use to access Tracker.

### Create a Yandex Lockbox secret {#create-secret}

Create a Yandex Lockbox [secret](../../lockbox/quickstart.md) to store your OAuth token and assign access permissions for the new secret to the service account.

{% list tabs group=instructions %}

- Management console {#console}

  1. In the [management console](https://console.yandex.cloud), select the [folder](../../resource-manager/concepts/resources-hierarchy.md#folder) where you created the service account earlier.
  1. Navigate to **Lockbox**.
  1. Click **Create secret**, and in the window that opens:

      1. In the **Name** field, specify the secret name: `tracker-oauth-token`.
      1. In the **Secret type** field, select `Custom`.
      1. In the **Key** field, enter the secret key: `oauth`.
      1. In the **Value** field, specify the application OAuth token you got in the previous step.
      1. Click **Create**.
  1. Click the row with the new secret (`tracker-oauth-token`) and do the following in the window that opens:

      1. Copy and save the **ID** field value. You will need it later when creating the workflow specification.
      1. Go to the ![persons](../../_assets/console-icons/persons.svg) **Access bindings** tab and click **Assign roles**.
      1. In the search bar, enter the name of the service account created earlier (`workflow-sa`) and select the service account you found.
      1. Click ![image](../../_assets/console-icons/plus.svg) **Add role** and select [`lockbox.payloadViewer`](../../lockbox/security/index.md#lockbox-payloadViewer).
      1. Click **Save**.

{% endlist %}

## Create an address and verify domain ownership in Yandex Cloud Postbox {#setup-postbox}

To enable the workflow to send emails, create a Yandex Cloud Postbox [address](../../postbox/concepts/glossary.md#adress) and verify the ownership of the sending domain.

### Create a Yandex Cloud Postbox address {#create-address}

1. Generate a key to create a DKIM signature by running this command in the terminal:

    ```bash
    openssl genrsa -out privatekey.pem 2048
    ```

    The new key will be saved in the `privatekey.pem` file in the current directory.

1. Create an address:

    {% list tabs group=instructions %}

    - Management console {#console}

        1. In the [management console](https://console.yandex.cloud), select the folder where you created the service account and secret.
        1. Navigate to **Cloud Postbox**.
        1. Click **Create address**.
        1. In the **Domain** field, specify the domain you will use to send emails, e.g., `example.com`.

            You can use a domain of any level. You must have permissions to add [resource records](../../dns/concepts/resource-record.md) to the public [DNS zone](../../dns/concepts/dns-zone.md) of the specified domain to verify your domain ownership.
        1. In the **Selector** field, specify a selector, e.g., `tracker_workflow`. 

            The name of the selector will be used to create a TXT resource record, so each selector you create must be unique within your domain.
        1. In the **Private key** field, copy the contents of the `privatekey.pem` file you created earlier.
        1. Click **Create address**.
        1. In the list of addresses that appears, select the new address and, under **Signature verification** on the page that opens, copy and save the **Name** and **Value** field values. You will need those to create a TXT resource record.

    {% endlist %}

### Verify your domain ownership {#validate-domain}

1. In the public DNS zone of your domain, create a [TXT resource record](../../dns/concepts/resource-record.md#txt) using the following values:

    * **Record name**: **Name** field value you copied in the previous step.

        In Yandex Cloud DNS, specify the name portion generated when creating the address (without specifying the domain) in `<selector>._domainkey` format, e.g., `tracker_workflow._domainkey`.

        For other DNS services, you may need to copy the entire record. The final record must look like this: `<selector>._domainkey.<domain>.`, e.g., `tracker_workflow._domainkey.example.com.`.

    * **Record type**: `TXT`.
    * **Record value**: **Value** field value you copied in the previous step.
    
        Note that the record value must be enclosed in quotes, such as follows:

        ```text
        "v=DKIM1;h=sha256;k=rsa;p=M1B...aCA8"
        ```

    {% note info %}
    
    If your domain is delegated to Yandex Cloud DNS, create a resource record according to [this guide](../../dns/operations/resource-record-create.md). Otherwise, use your domain name registrar's personal account. If you have any questions, refer to the relevant documentation or contact the registrar's support service.
    
    {% endnote %}

1. Verify your domain ownership.

    {% list tabs group=instructions %}

    - Management console {#console}

        1. In the [management console](https://console.yandex.cloud), select the folder that contains the address you created.
        1. Navigate to **Cloud Postbox** and select the address.
        1. Click **Run verification**. If the TXT record is created correctly, the verification status on the address page will change to `Success`.

            DNS server responses are cached, so you may experience delays when updating the resource record.

    {% endlist %}

## Create a workflow {#setup-workflow}

1. Select the specification you will use to create your workflow. Both specifications use integrations with Yandex Tracker, Yandex Cloud AI Studio, and Yandex Cloud Postbox; however, they analyze the input data differently.

    {% list tabs %}

    - Option 1

      {% note tip %}
      
      This guide describes how to create a workflow using the YaWL specification; however, you can also create and edit workflows using the [constructor](../../serverless-integrations/operations/workflows/constructor/index.md).
      
      {% endnote %}

      ![tracker-yandexgpt-postbox-integrations-first-workflow](../../_assets/tutorials/tracker-yandexgpt-postbox-integrations-first-workflow.png)

      The suggested workflow will analyze the Tracker issues in the specified queue, generate and publish a progress report for these issues:

      1. Analyzing issues with specified tag in a given Tracker queue:
          * Total number of issues.
          * Total sum of [Story Points](https://yandex.ru/support/tracker/ruglossary#en-s) awarded to issues.
          * Number of closed issues.
          * Percentage ratio of the number of closed issues to the total number of issues.
          * Sum of `Story Points` awarded to closed issues.
          * Percentage ratio of the sum of `Story Points` awarded to closed issues to the total sum of `Story Points` awarded to all issues.
      1. Generating a report with the results of the analysis.
      1. Publishing a report in a comment to a specified Tracker issue, sending the report to a specified email address.

      **Specification code**:

      ```yaml
      yawl: "0.1"
      start: fetch_tickets
      steps:
        fetch_tickets:
          tracker:
            organization:
              cloudOrganizationId: <organization_ID>
            oauthToken: '\(lockboxPayload("<secret_ID>"; "oauth"))'
            listIssues:
              filter:
                issueProperties:
                  queue: <queue_key_in_Tracker>
                  tags: "product"
            output: |-
              \({
                "sp_sum": [.[].storyPoints] | add,
                "closed_sp_sum": . | map(select(.status.key == "closed")) | map(.storyPoints) | add,
                "ticket_count": . | length,
                "closed_ticket_count": . | map(select(.status.key == "closed")) | length,
                "non_closed_ticket_texts": . | map(select(.status.key != "closed")) | map({
                  "key": .key,
                  "summary": .summary,
                  "description": .description            
                })
              })
            next: summarize_texts
        summarize_texts:
          foundationModelsCall:
            next: create_report
            modelUrl: gpt://<folder_ID>/yandexgpt
            generate:
              maxTokens: 500
              temperature: 0.5
              messages:
                messages:
                  - role: system
                    text: "Next you will get names of unfinished Tracker issues and their descriptions. State as briefly as possible (no more than three sentences) what remains to be done"
                  - role: user
                    text: |-
                      \("
                        \(.non_closed_ticket_texts | map(.summary + ": " + .description) | join(". "))
                      ")
            output: |-
              \({
                "summary": .alternatives.[0].message.text
              })
        create_report:
          noOp:
            output: |-
              \({
              "report_text": "**Total amount of work:** \(.ticket_count) issue(s), \(.sp_sum) sp
              **Work completed:** \(.closed_ticket_count) (\(100 * .closed_ticket_count / .ticket_count | round)%) issue(s), \(.closed_sp_sum) (\(100 * .closed_sp_sum / .sp_sum | round)%) sp

              **Unfinished issues:**
                \(.non_closed_ticket_texts | map(.key) | join("\n"))

              **Summary of what remains:**
                \(.summary)
              ",
              "report_text_html": "<b>Total amount of work:</b> \(.ticket_count) issue(s), \(.sp_sum) sp<br>
              <b>Work completed:</b> \(.closed_ticket_count) (\(100 * .closed_ticket_count / .ticket_count | round)%) issue(s), \(.closed_sp_sum) (\(100 * .closed_sp_sum / .sp_sum | round)%) sp<br>
              <br>
              <b>Unfinished issues:</b><br>
                \(.non_closed_ticket_texts | map("<a href=https://tracker.yandex.ru/" + .key + ">" + .key + "</a>") | join("<br>"))<br>
              <br>
              <b>Summary of what remains:</b><br>
                \(.summary | gsub("\\n"; "<br>"))
              "})
            next: deliver_report
        deliver_report:
          parallel:
            branches:
              tracker:
                start: write_report_to_tracker
                steps:
                  write_report_to_tracker:
                    tracker:
                      organization:
                        cloudOrganizationId: <organization_ID>
                      oauthToken: '\(lockboxPayload("<secret_ID>"; "oauth"))'
                      createComment:
                        key: <issue_key_with_report>
                        text: \(.report_text)
              postbox:
                start: send_report_via_postbox
                steps:
                  send_report_via_postbox:
                    postbox:
                      simple:
                        subject:
                          data: "Dev progress report"
                          charset: UTF_8
                        body:
                          text:
                            data: \(.report_text)
                            charset: UTF_8
                          html:
                            data: \("<p>\(.report_text_html)</p>")
                            charset: UTF_8
                      fromAddress: tracker-robot@<your_domain>
                      destination:
                        toAddresses: <recipient_address>
      ```

      Where:

      * `<organization_ID>`: [ID](../../organization/operations/organization-get-id.md) of your Yandex Identity Hub.
      * `<secret_ID>`: Previously saved [secret](../../lockbox/concepts/secret.md) ID with the application's OAuth token.
      * `<queue_key_in_Tracker>`: [Key](https://yandex.ru/support/tracker/ruglossary#rus-k) of the Tracker queue where you created the test issues.
      * `<folder_ID>`: [ID](../../resource-manager/operations/folder/get-id.md) of the folder where you are creating a workflow.
      * `<issue_key_with_report>`: Key of the Tracker [issue](https://yandex.ru/support/tracker/ruglossary#rus-z) in the comment to which the summary of the analyzed test issues will be uploaded.
      * `<your_domain>`: Domain you specified when creating the Yandex Cloud Postbox address. For the sender address (`fromAddress`), you can specify any address on this domain, e.g., `tracker-robot@example.com` or `noreply@example.com`.
      * `<recipient_address>`: Email address to which the workflow will send a summary of the analyzed Tracker test issues.

      A workflow comprises the following steps: `fetch_tickets`, `summarize_texts`, `send_report_via_postbox`, and `write_report_to_tracker`.

    - Option 2

      {% note tip %}
      
      This guide describes how to create a workflow using the YaWL specification; however, you can also create and edit workflows using the [constructor](../../serverless-integrations/operations/workflows/constructor/index.md).
      
      {% endnote %}

      ![tracker-yandexgpt-postbox-integrations-second-workflow](../../_assets/tutorials/tracker-yandexgpt-postbox-integrations-second-workflow.png)

      The suggested workflow will analyze closed Tracker issues for the last week, generate and publish a progress report for these issues:
      1. Analysis of issues closed over the past week:
          * Uploading comments to issues.
          * Analysis and summation of comments for each closed issue.
      1. Generating a report summarizing the work done for each closed issue.
      1. Publishing the report in a comment to a specified Tracker issue, sending the report to a specified email address.

      **Specification code**:

      ```yaml
      yawl: "0.1"
      start: fetch_tickets
      steps:
        fetch_tickets:
          tracker:
            organization:
              cloudOrganizationId: <organization_ID>
            oauthToken: '\(lockboxPayload("<secret_ID>"; "oauth"))'
            listIssues:
              query: 'Status: changed(to: Closed date: >now()-2w)'
            output: |-
              \({
                "closed_tickets": . | map({"ticket_key": .key})
              })
            next: fetch_comments_fe
        fetch_comments_fe:
          foreach:
            input: \(.closed_tickets)
            do:
              start: fetch_comments
              steps:
                fetch_comments:
                  tracker:
                    organization:
                      cloudOrganizationId: <organization_ID>
                    oauthToken: '\(lockboxPayload("<secret_ID>"; "oauth"))'
                    listComments:
                      key: \(.ticket_key)
                    output: |-
                      \({
                        "comments": .
                      })
            output: |-
              \({
                "comment_text": map(.comments[].text) | join("\n")
              })
            next: summarize_texts
        summarize_texts:
          foundationModelsCall:
            modelUrl: gpt://<folder_ID>/yandexgpt
            generate:
              maxTokens: 500
              temperature: 0.5
              messages:
                messages:
                  - role: system
                    text: "Next you will get comments of completed issues in Tracker. State as briefly as possible (no more than three sentences) what work has been done."
                  - role: user
                    text: \(.comment_text)
            output: |-
              \({
                "summary": .alternatives.[0].message.text
              })
            next: create_report
        create_report:
          noOp:
            output: |-
              \({
                "report_text": "
                  Completed issues:
                    \(.closed_tickets | map(.ticket_key) | join("\n"))
                  Summary of closed issues:
                    \(.summary)
                ",
                "report_text_html": "
                  Completed issues:<br>
                    \(.closed_tickets | map("<a href=https://tracker.yandex.ru/" + .ticket_key + ">" + .ticket_key + "</a>") | join("<br>"))<br>

                  <br>
                  Summary of closed issues:<br>
                    \(.summary | gsub("\\n"; "<br>")))
                "
              })
            next: deliver_report
        deliver_report:
          parallel:
            branches:
              tracker:
                start: write_report_to_tracker
                steps:
                  write_report_to_tracker:
                    tracker:
                      organization:
                        cloudOrganizationId: <organization_ID>
                      oauthToken: '\(lockboxPayload("<secret_ID>"; "oauth"))'
                      createComment:
                        key: <issue_key_with_report>
                        text: \(.report_text)
              postbox:
                start: send_report_via_postbox
                steps:
                  send_report_via_postbox:
                    postbox:
                      simple:
                        subject:
                          data: "Dev progress report (closed issues)"
                          charset: UTF_8
                        body:
                          text:
                            data: \(.report_text)
                            charset: UTF_8
                          html:
                            data: \("<p>\(.report_text_html)</p>")
                            charset: UTF_8
                      fromAddress: tracker-robot@<your_domain>
                      destination:
                        toAddresses: <recipient_address>
        ```

      Where:

      * `<organization_ID>`: [ID](../../organization/operations/organization-get-id.md) of your Yandex Identity Hub.
      * `<secret_ID>`: Previously saved [secret](../../lockbox/concepts/secret.md) ID with the application's OAuth token.
      * `<folder_ID>`: [ID](../../resource-manager/operations/folder/get-id.md) of the folder where you are creating a workflow.
      * `<issue_key_with_report>`: Key of the Tracker [issue](https://yandex.ru/support/tracker/ruglossary#rus-z) in the comment to which the summary of the analyzed test issues will be uploaded.
      * `<your_domain>`: Domain you specified when creating the Yandex Cloud Postbox address. For the sender address (`fromAddress`) you can specify any address on this domain, e.g., `tracker-robot@example.com` or `noreply@example.com`.
      * `<recipient_address>`: Email address to which the workflow will send a summary of the analyzed Tracker test issues.

      A workflow comprises the following steps: `fetch_tickets`, `fetch_comments`, `summarize_texts`, `send_report_via_postbox`, and `write_report_to_tracker`.

    {% endlist %}

1. Create a workflow using the selected specification:

    {% list tabs group=instructions %}

    - Management console {#console}

        1. In the [management console](https://console.yandex.cloud), select the folder containing the previously created resources: service account, secret, and Yandex Cloud Postbox address.
        1. Navigate to **Serverless Integrations**.
        1. In the left-hand panel, select ![GraphNode](../../_assets/console-icons/graph-node.svg) **Workflows**.
        1. In the top-right corner, click **Create workflow** and in the window that opens:

            1. In the **YaML specification** field, add the previously selected specification.
            1. Expand **Additional parameters**.
            1. In the **Name** field, enter the workflow name: `my-tracker-workflow`.
            1. In the **Service account** field, select the `workflow-sa` service account you previously created.
        1. Click **Create**.

    {% endlist %}

## Test the workflow {#test}

Make sure the workflow is running successfully.

{% list tabs group=instructions %}

- Management console {#console}

    1. In the [management console](https://console.yandex.cloud), select the folder with the workflow you created.
    1. Navigate to **Serverless Integrations**.
    1. In the left-hand panel, select ![GraphNode](../../_assets/console-icons/graph-node.svg) **Workflows**.
    1. Click ![ellipsis](../../_assets/console-icons/ellipsis.svg) next to `my-tracker-workflow` and select ![TriangleRight](../../_assets/console-icons/triangle-right.svg) **Execute**.
    1. In the window that opens, click **Start**. The workflow will run and may take a few minutes to complete.
    1. Navigate to the ![Timeline](../../_assets/console-icons/timeline.svg) **Timeline** tab.

        Make sure all workflow steps are completed successfully. Each successful step will be marked by a green box with the ![CircleCheck](../../_assets/console-icons/circle-check.svg) icon in the relevant line of the time scale.

        If there is an error at any of the steps, a red box with the ![TriangleExclamation](../../_assets/console-icons/triangle-exclamation.svg) icon will be displayed in the relevant line of the time scale. Click this box to view the error details.

{% endlist %}

As a result of the workflow, a comment with a summary of the analyzed test issues will be added to the Tracker issue named in the specification. This summary will also be sent to the email address given in the specification.

## How to delete the resources you created {#clear-out}

To stop paying for the resources you created:
1. Delete the workflow:

    {% list tabs group=instructions %}

    - Management console {#console}

        1. In the [management console](https://console.yandex.cloud), select the folder containing the created resources.
        1. Navigate to **Serverless Integrations**.
        1. In the left-hand panel, select ![GraphNode](../../_assets/console-icons/graph-node.svg) **Workflows**.
        1. Click ![ellipsis](../../_assets/console-icons/ellipsis.svg) next to `my-tracker-workflow` and select ![TrashBin](../../_assets/console-icons/trash-bin.svg) **Delete**.
        1. Confirm the deletion.

    {% endlist %}
1. [Delete the secret](../../lockbox/operations/secret-delete.md).
1. Delete the Tracker [issues](https://yandex.ru/support/tracker/ruuser/ticket-cancel) and [queue](https://yandex.ru/support/tracker/rumanager/delete-queue).
1. Optionally, delete the Yandex Cloud Postbox address:

    {% list tabs group=instructions %}

    - Management console {#console}

        1. In the [management console](https://console.yandex.cloud), select the folder with the Yandex Cloud Postbox address.
        1. Navigate to **Cloud Postbox**.
        1. In the row with the Yandex Cloud Postbox address, click ![ellipsis](../../_assets/console-icons/ellipsis.svg) and select ![TrashBin](../../_assets/console-icons/trash-bin.svg) **Delete**.
        1. Confirm the deletion.

    {% endlist %}