> [!CAUTION]
>
> **Note:**
> This content applies only to Cloud Run functions (1st gen)---formerly Cloud Functions (1st gen).
>
>
> For the Cloud Run functions version of this document, see the
> [Workflows tutorial](https://docs.cloud.google.com/functions/docs/tutorials/workflows).

This tutorial shows you how to use Workflows to link a series of
services together. By connecting two public HTTP services (using Cloud Run functions),
an external REST API, and a private Cloud Run service, you can
create a flexible, serverless application.

## Objectives

In this tutorial, you use the Google Cloud CLI to create a single workflow,
connecting one service at a time:

1. Deploy two Cloud Run functions services: the first function generates a random number, and then passes that number to the second function which multiplies it.
2. Using Workflows, connect the two HTTP functions together. Execute the workflow and return a result that is then passed to an external API.
3. Using Workflows, connect an external HTTP API that returns the `log` for a given number. Execute the workflow and return a result that is then passed to a Cloud Run service.
4. Deploy a Cloud Run service that allows authenticated access only. The service returns the `math.floor` for a given number.
5. Using Workflows, connect the Cloud Run service, execute the entire workflow, and return a final result.

The following diagram shows both an overview of the process as well as a
visualization of the final workflow:

<br />

![Workflows visualization](https://docs.cloud.google.com/static/workflows/images/workflows-run-visualization.svg)

## Costs


In this document, you use the following billable components of Google Cloud:


- [Artifact Registry](https://docs.cloud.google.com/artifact-registry)
- [Cloud Build](https://docs.cloud.google.com/build)
- [Cloud Run functions](https://docs.cloud.google.com/functions)
- [Cloud Run](https://docs.cloud.google.com/run)
- [Cloud Storage](https://docs.cloud.google.com/storage)
- [Workflows](https://docs.cloud.google.com/workflows)


To generate a cost estimate based on your projected usage,
use the [pricing calculator](https://docs.cloud.google.com/products/calculator).
New Google Cloud users might be eligible for a [free trial](https://docs.cloud.google.com/free).

<br />

## Before you begin

Security constraints defined by your organization might prevent you from completing the
following steps. For troubleshooting information, see
[Develop applications in a constrained Google Cloud environment](https://docs.cloud.google.com/resource-manager/docs/organization-policy/develop-apps-constrained-environment).

1. Update the Google Cloud CLI components:

   ```bash
   gcloud components update
   ```
2. If you are running commands inside Cloud Shell, you are already authenticated with the gcloud CLI; otherwise, sign in using your account:

   ```bash
   gcloud auth login
   ```
3. Create a service account for Workflows to use:<br />

   ```bash
   export SERVICE_ACCOUNT=workflows-sa
   gcloud iam service-accounts create ${SERVICE_ACCOUNT}
   ```

   <br />

4. To allow the service account to call authenticated Cloud Run services, grant the `run.invoker` role to the Workflows service account:

   <br />

   ```bash
   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:${SERVICE_ACCOUNT}@PROJECT_ID.iam.gserviceaccount.com" \
       --role "roles/run.invoker"
   ```

   Replace `PROJECT_ID` with your Google Cloud project ID.
5. Set the default location used in this tutorial:

   ```bash
   gcloud config set project PROJECT_ID
   export REGION=REGION
   gcloud config set functions/region ${REGION}
   gcloud config set run/region ${REGION}
   gcloud config set workflows/location ${REGION}
   ```

   <br />

   Replace `REGION` with the supported Workflows
   [location](https://docs.cloud.google.com/workflows/docs/locations.md.txt) of your choice.

<br />

## Deploy the first Cloud Run functions service

After receiving an HTTP request, this HTTP function generates a random number
between 1 and 100, and then returns the number in JSON format.

1. Create a directory called `randomgen` and change to it:

   ```bash
   mkdir ~/randomgen
   cd ~/randomgen
   ```
2. Create a text file with the filename `main.py` that contains the following
   Python code:

   ```python
   import functions_framework
   import random
   from flask import jsonify


   @functions_framework.http
   def randomgen(request):
       randomNum = random.randint(1, 100)
       output = {"random": randomNum}
       return jsonify(output)
   ```
3. To support a dependency on Flask for HTTP processing, create a text file for
   the pip package manager. Give it the filename `requirements.txt` and add the
   following:

       flask>=1.0.2
       functions-framework==3.0.0

4. Deploy the function with an HTTP trigger, and allow unauthenticated access:

   ```bash
   gcloud functions deploy randomgen \
       --runtime python37 \
       --trigger-http \
       --allow-unauthenticated
   ```

The function might take a few minutes to deploy. Alternatively, you can
[use the Cloud Run functions interface](https://docs.cloud.google.com/functions/docs/deploying/console)
in the Google Cloud console to deploy the function.

1. Once the function is deployed, you can confirm the `httpsTrigger.url` property:

   ```bash
   gcloud functions describe randomgen
   ```
2. You can try out the function with the following curl command:

   ```bash
   curl $(gcloud functions describe randomgen --format='value(httpsTrigger.url)')
   ```

   A number is randomly generated and returned.

## Deploy the second Cloud Run functions service

After receiving an HTTP request, this HTTP function extracts the `input` from
the JSON body, multiplies it by 2, and returns the result in JSON format.

1. Create a directory called `multiply` and change to it:

   ```bash
   mkdir ~/multiply
   cd ~/multiply
   ```
2. Create a text file with the filename `main.py` that contains the following
   Python code:

   ```python
   import functions_framework
   from flask import jsonify


   @functions_framework.http
   def multiply(request):
       request_json = request.get_json()
       output = {"multiplied": 2 * request_json['input']}
       return jsonify(output)
   ```
3. To support a dependency on Flask for HTTP processing, create a text file for
   the pip package manager. Give it the filename `requirements.txt` and add the
   following:

       flask>=1.0.2
       functions-framework==3.0.0

4. Deploy the function with an HTTP trigger, and allow unauthenticated access:

   ```bash
   gcloud functions deploy multiply \
       --runtime python37 \
       --trigger-http \
       --allow-unauthenticated
   ```

The function might take a few minutes to deploy.Alternatively, you can
[use the Cloud Run functions interface](https://docs.cloud.google.com/functions/docs/deploying/console)
in the Google Cloud console to deploy the function.

1. Once the function is deployed, you can confirm the `httpsTrigger.url` property:

   ```bash
   gcloud functions describe multiply
   ```
2. You can try out the function with the following curl command:

   ```bash
   curl $(gcloud functions describe multiply --format='value(httpsTrigger.url)') \
       -X POST \
       -H "content-type: application/json" \
       -d '{"input": 5}'
   ```

   The number 10 should be returned.

## Connect the two Cloud Run functions services in a workflow

A workflow is made up of a series of steps described using the
Workflows syntax, which can be written in either YAML or JSON
format. This is the workflow's definition. For a detailed explanation, see the
[Syntax reference](https://docs.cloud.google.com/workflows/docs/reference/syntax.md.txt) page.

1. Navigate back to your home directory:

   ```bash
   cd ~
   ```
2. Create a text file with the filename `workflow.yaml` that contains the following
   content:

   ```yaml
   - randomgen_function:
       call: http.get
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/randomgen
       result: randomgen_result
   - multiply_function:
       call: http.post
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/multiply
           body:
               input: ${randomgen_result.body.random}
       result: multiply_result
   - return_result:
       return: ${multiply_result}
   ```

   This links the two HTTP functions together and returns a final result.

   > [!NOTE]
   > **Note:** To make a request to a Cloud Run functions function that accepts only authenticated calls, use OIDC to authenticate. For more information, see [Make authenticated requests from a workflow](https://docs.cloud.google.com/workflows/docs/authenticate-from-workflow.md.txt).

3. After creating the workflow, you can deploy it, which makes it ready for
   execution.

   ```bash
   gcloud workflows deploy WORKFLOW_NAME --source=workflow.yaml
   ```

   Replace `WORKFLOW_NAME` with a name for your workflow.
4. Execute the workflow:

   ```bash
   gcloud workflows run WORKFLOW_NAME
   ```

   An execution is a single run of the logic contained in a workflow's definition.
   All workflow executions are independent, and the rapid scaling of
   Workflows allows for a high number of concurrent executions.

   After the workflow is executed, the output should resemble the following:

       result: '{"body":{"multiplied":120},"code":200,"headers":{"Alt-Svc":"h3-29=\":443\";
       ...
       startTime: '2021-05-05T14:17:39.135251700Z'
       state: SUCCEEDED
       ...

## Connect a public REST service in the workflow

Update your existing workflow and connect a public REST API
([math.js](https://api.mathjs.org/))
that can evaluate mathematical expressions. For example,
`curl https://api.mathjs.org/v4/?'expr=log(56)'`.

Note that since you have deployed your workflow, you can also edit it through
the
[Workflows page in the Google Cloud console](https://console.cloud.google.com/workflows).

1. Edit the source file for your workflow and replace it with the following
   content:

   ```yaml
   - randomgen_function:
       call: http.get
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/randomgen
       result: randomgen_result
   - multiply_function:
       call: http.post
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/multiply
           body:
               input: ${randomgen_result.body.random}
       result: multiply_result
   - log_function:
       call: http.get
       args:
           url: https://api.mathjs.org/v4/
           query:
               expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
       result: log_result
   - return_result:
       return: ${log_result}
   ```

   This links the external REST service to the Cloud Run functions services,
   and returns a final result.
2. Deploy the modified workflow:

   ```bash
   gcloud workflows deploy WORKFLOW_NAME --source=workflow.yaml
   ```

## Deploy a Cloud Run service

Deploy a Cloud Run service that, after receiving an HTTP
request, extracts `input` from the JSON body, calculates its `math.floor`, and
returns the result.

1. Create a directory called `floor` and change to it:

   ```bash
   mkdir ~/floor
   cd ~/floor
   ```
2. Create a text file with the filename `app.py` that contains the following
   Python code:


   ```python
   import json
   import logging
   import os
   import math

   from flask import Flask, request

   app = Flask(__name__)


   @app.route('/', methods=['POST'])
   def handle_post():
       content = json.loads(request.data)
       input = float(content['input'])
       return f"{math.floor(input)}", 200


   if __name__ != '__main__':
       # Redirect Flask logs to Gunicorn logs
       gunicorn_logger = logging.getLogger('gunicorn.error')
       app.logger.handlers = gunicorn_logger.handlers
       app.logger.setLevel(gunicorn_logger.level)
       app.logger.info('Service started...')
   else:
       app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))
   ```

   <br />

3. In the same directory, create a `Dockerfile` with the following content:


   ```docker
   # Use an official lightweight Python image.
   # https://hub.docker.com/_/python
   FROM python:3.7-slim

   # Install production dependencies.
   RUN pip install Flask gunicorn

   # Copy local code to the container image.
   WORKDIR /app
   COPY . .

   # Run the web service on container startup. Here we use the gunicorn
   # webserver, with one worker process and 8 threads.
   # For environments with multiple CPU cores, increase the number of workers
   # to be equal to the cores available.
   CMD exec gunicorn --bind 0.0.0.0:8080 --workers 1 --threads 8 app:app
   ```

   <br />

4. Create an Artifact Registry standard repository where you can store your
   Docker container image:

   ```bash
   gcloud artifacts repositories create REPOSITORY \
       --repository-format=docker \
       --location=${REGION}
   ```

   Replace `REPOSITORY` with a unique name for the
   repository.
5. Build the container image:

   ```bash
   export SERVICE_NAME=floor
   gcloud builds submit --tag ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}
   ```
6. Deploy the container image to Cloud Run, ensuring that it only
   accepts authenticated calls:

   ```bash
   gcloud run deploy ${SERVICE_NAME} \
       --image ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}:latest \
       --platform managed \
       --no-allow-unauthenticated
   ```

When you see the service URL, the deployment is complete. You will need to
specify that URL when updating the workflow definition.

## Connect the Cloud Run service in the workflow

Update your existing workflow and specify the URL for the Cloud Run
service.

1. Edit the source file for your workflow and replace it with the following
   content:

   ```yaml
   - randomgen_function:
       call: http.get
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/randomgen
       result: randomgen_result
   - multiply_function:
       call: http.post
       args:
           url: https://REGION-PROJECT_ID.cloudfunctions.net/multiply
           body:
               input: ${randomgen_result.body.random}
       result: multiply_result
   - log_function:
       call: http.get
       args:
           url: https://api.mathjs.org/v4/
           query:
               expr: ${"log(" + string(multiply_result.body.multiplied) + ")"}
       result: log_result
   - floor_function:
       call: http.post
       args:
           url: CLOUD_RUN_SERVICE_URL
           auth:
               type: OIDC
           body:
               input: ${log_result.body}
       result: floor_result
   - create_output_map:
       assign:
         - outputMap:
             randomResult: ${randomgen_result}
             multiplyResult: ${multiply_result}
             logResult: ${log_result}
             floorResult: ${floor_result}
   - return_output:
       return: ${outputMap}
   ```

   Replace `CLOUD_RUN_SERVICE_URL` with your
   Cloud Run service URL.

   This connects the Cloud Run service in the workflow. Note
   that the `auth` key ensures that an authentication token is being passed in
   the call to the Cloud Run service. For more information,
   see [Make authenticated requests from a workflow](https://docs.cloud.google.com/workflows/docs/authenticate-from-workflow.md.txt).
2. Deploy the modified workflow:

   ```bash
   gcloud workflows deploy WORKFLOW_NAME \
       --source=workflow.yaml
   ```
3. Execute the final workflow:

   ```bash
   gcloud workflows run WORKFLOW_NAME
   ```

   The output should resemble the following:

       result: '{"Floor":{"body":"4","code":200
         ...
         "Log":{"body":"4.02535169073515","code":200
         ...
         "Multiply":{"body":{"multiplied":56},"code":200
         ...
         "Random":{"body":{"random":28},"code":200
         ...
       startTime: '2023-11-13T21:22:56.782669001Z'
       state: SUCCEEDED

Congratulations! You have deployed and executed a workflow that connects a
series of services together.

To create more complex workflows using expressions, conditional jumps,
Base64 encoding or decoding, subworkflows, and more, refer to the
[Workflows syntax reference](https://docs.cloud.google.com/workflows/docs/reference/syntax.md.txt)
and the [Standard library overview](https://docs.cloud.google.com/workflows/docs/reference/stdlib/overview.md.txt).

## Clean up

If you created a new project for this tutorial, [delete the project](https://docs.cloud.google.com/functions/1stgendocs/tutorials/workflows-1st-gen.md.txt#delete-project).
If you used an existing project and want to keep it without the changes added
in this tutorial, [delete resources created for the tutorial](https://docs.cloud.google.com/functions/1stgendocs/tutorials/workflows-1st-gen.md.txt#delete-resources).

### Delete the project


The easiest way to eliminate billing is to delete the project that you
created for the tutorial.

To delete the project:

> [!CAUTION]
> **Caution** : Deleting a project has the following effects:
>
> - **Everything in the project is deleted.** If you used an existing project for the tasks in this document, when you delete it, you also delete any other work you've done in the project.
> - **Custom project IDs are lost.** When you created this project, you might have created a custom project ID that you want to use in the future. To preserve the URLs that use the project ID, such as an `appspot.com` URL, delete selected resources inside the project instead of deleting the whole project.
>
>
> If you plan to explore multiple architectures, tutorials, or quickstarts, reusing projects
> can help you avoid exceeding project quota limits.

1. In the Google Cloud console, go to the **Manage resources** page.

   [Go to Manage resources](https://console.cloud.google.com/iam-admin/projects)
2. In the project list, select the project that you want to delete, and then click **Delete**.
3. In the dialog, type the project ID, and then click **Shut down** to delete the project.

<br />

<br />

### Delete tutorial resources

- [Delete the Cloud Run service](https://docs.cloud.google.com/run/docs/managing/services.md.txt#delete)
  you deployed in this tutorial.

- [Delete the workflow](https://docs.cloud.google.com/workflows/docs/creating-updating-workflow.md.txt#delete-workflow)
  you created in this tutorial.

- [Delete the container image](https://docs.cloud.google.com/artifact-registry/docs/docker/manage-images.md.txt#deleting_images)
  from Artifact Registry.

- [Delete the Artifact Registry repository](https://docs.cloud.google.com/artifact-registry/docs/repositories/delete-repos.md.txt).

- Remove the Google Cloud CLI default configurations you added during the
  tutorial setup:

  ```bash
  gcloud config unset functions/region
  gcloud config unset run/region
  gcloud config unset workflows/location
  gcloud config unset project
  ```

## What's next

- [Learn more about Workflows](https://docs.cloud.google.com/workflows/docs/overview.md.txt)
- [Workflows syntax reference](https://docs.cloud.google.com/workflows/docs/reference/syntax.md.txt)