Diese Seite wurde von der Cloud Translation API übersetzt.

Workflows mit Cloud Run und Cloud Run Functions verwenden

In dieser Anleitung erfahren Sie, wie Sie mit Workflows eine Reihe von Diensten miteinander verknüpfen. Wenn Sie zwei öffentliche HTTP-Dienste (mit Cloud Run Functions), eine externe REST API und einen privaten Cloud Run-Dienst verbinden, können Sie eine flexible, serverlose Anwendung erstellen.

Erste Cloud Run Functions bereitstellen

Nach dem Empfang einer HTTP-Anfrage generiert diese HTTP-Funktion eine zufällige Zahl zwischen 1 und 100 und gibt die Zahl im JSON-Format zurück.

Erstellen Sie ein Verzeichnis mit dem Namen randomgen und rufen Sie es auf:
```
mkdir ~/randomgen
cd ~/randomgen
```

Erstellen Sie eine Textdatei mit dem Dateinamen main.py, die den folgenden Python-Code enthält:

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)

Erstellen Sie eine Textdatei für den pip-Paketmanager, um eine Abhängigkeit von Flask für die HTTP-Verarbeitung zu unterstützen. Geben Sie der Datei den Namen requirements.txt und fügen Sie Folgendes hinzu:
```
flask>=1.0.2
functions-framework==3.0.0
```
Stellen Sie die Funktion mit einem HTTP-Trigger bereit und lassen Sie nicht authentifizierten Zugriff zu:
```
gcloud functions deploy randomgen-function \
    --gen2 \
    --runtime python310 \
    --entry-point=randomgen \
    --trigger-http \
    --allow-unauthenticated
```
Die Bereitstellung der Funktion kann einige Minuten dauern. Alternativ können Sie die Funktion über die Cloud Run Functions-Oberfläche in der Google Cloud -Console bereitstellen.

Nachdem die Funktion randomgen bereitgestellt wurde, können Sie das Attribut httpsTrigger.url bestätigen:

gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)"

Speichern Sie die URL. Sie müssen sie in späteren Übungen Ihrer Workflows-Quelldatei hinzufügen.
Sie können die Funktion mit dem folgenden curl-Befehl ausprobieren:
```
curl $(gcloud functions describe randomgen-function \
    --gen2 \
    --format="value(serviceConfig.uri)")
```
Es wird eine zufällige Zahl generiert und zurückgegeben.

Zweite Cloud Run-Funktion bereitstellen

Nach dem Empfangen einer HTTP-Anfrage extrahiert diese HTTP-Funktion den input aus dem JSON-Text, multipliziert ihn mit 2 und gibt das Ergebnis im JSON-Format zurück.

Gehen Sie zurück zum Basisverzeichnis:
```
cd ~
```
Erstellen Sie ein Verzeichnis mit dem Namen multiply und rufen Sie es auf:
```
mkdir ~/multiply
cd ~/multiply
```

Erstellen Sie eine Textdatei mit dem Dateinamen main.py, die den folgenden Python-Code enthält:

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)

Erstellen Sie eine Textdatei für den pip-Paketmanager, um eine Abhängigkeit von Flask für die HTTP-Verarbeitung zu unterstützen. Geben Sie der Datei den Namen requirements.txt und fügen Sie Folgendes hinzu:
```
flask>=1.0.2
functions-framework==3.0.0
```
Stellen Sie die Funktion mit einem HTTP-Trigger bereit und lassen Sie nicht authentifizierten Zugriff zu:
```
gcloud functions deploy multiply-function \
    --gen2 \
    --runtime python310 \
    --entry-point=multiply \
    --trigger-http \
    --allow-unauthenticated
```
Die Bereitstellung der Funktion kann einige Minuten dauern. Alternativ können Sie die Funktion über die Cloud Run Functions-Oberfläche in der Google Cloud -Console bereitstellen.

Nachdem die Funktion multiply bereitgestellt wurde, können Sie das Attribut httpsTrigger.url bestätigen:

gcloud functions describe multiply-function \
    --gen2\
    --format="value(serviceConfig.uri)"

Speichern Sie die URL. Sie müssen sie in späteren Übungen Ihrer Workflows-Quelldatei hinzufügen.

Sie können die Funktion mit dem folgenden curl-Befehl ausprobieren:

curl -X POST MULTIPLY_FUNCTION_URL \
    -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"input": 5}'

Es sollte die Zahl 10 zurückgegeben werden.

Die beiden Cloud Run Functions-Dienste in einem Workflow verbinden

Ein Workflow besteht aus einer Reihe von Schritten, die mit der Workflows-Syntax beschrieben werden. Diese kann entweder im YAML- oder JSON-Format geschrieben werden. Dies ist die Definition des Workflows. Eine ausführliche Erläuterung finden Sie auf der Seite Syntaxreferenz.

Gehen Sie zurück zum Basisverzeichnis:
```
cd ~
```
Erstellen Sie eine Textdatei mit dem Dateinamen workflow.yaml, die den folgenden Inhalt enthält:
```
- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        body:
            input: ${randomgen_result.body.random}
    result: multiply_result
- return_result:
    return: ${multiply_result}
```
- Ersetzen Sie RANDOMGEN_FUNCTION_URL durch die URL Ihrer randomgen-Funktion.
- Ersetzen Sie MULTIPLY_FUNCTION_URL durch die URL Ihrer multiply-Funktion.
Diese Quelldatei verknüpft die beiden HTTP-Funktionen und gibt ein Endergebnis zurück.

Hinweis: Verwenden Sie OIDC zur Authentifizierung, um eine Anfrage an eine Cloud Run-Funktion zu senden, die nur authentifizierte Aufrufe akzeptiert. Weitere Informationen finden Sie unter Authentifizierte Anfragen von einem Workflow aus ausführen.
Nachdem Sie den Workflow erstellt haben, können Sie ihn bereitstellen, wodurch er für die Ausführung bereit ist.
```
gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.
```
Ersetzen Sie WORKFLOW_NAME mit einem Namen für Ihren Workflow.
Führen Sie den Workflow aus:
```
gcloud workflows run WORKFLOW_NAME
```
Eine Ausführung ist ein einzelner Durchlauf der Logik, die in der Definition eines Workflows enthalten ist. Alle Workflowausführungen sind unabhängig und die schnelle Skalierung von Workflows ermöglicht eine hohe Anzahl gleichzeitiger Ausführungen.

Nachdem der Workflow ausgeführt wurde, sollte die Ausgabe in etwa so aussehen:
```
result: '{"body":{"multiplied":120},"code":200,"headers":{"Alt-Svc":"h3-29=\":443\";
...
startTime: '2021-05-05T14:17:39.135251700Z'
state: SUCCEEDED
...
```

Öffentlichen REST-Dienst mit dem Workflow verbinden

Aktualisieren Sie Ihren vorhandenen Workflow und verbinden Sie eine öffentliche REST API (math.js), die mathematische Ausdrücke auswerten kann. Beispiel: curl https://api.mathjs.org/v4/?'expr=log(56)'

Da Sie Ihren Workflow bereitgestellt haben, können Sie ihn auch auf der Seite „Workflows“ in der Google Cloud -Konsole bearbeiten.

Bearbeiten Sie die Quelldatei für Ihren Workflow und ersetzen Sie sie durch folgenden Inhalt:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        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}

Ersetzen Sie RANDOMGEN_FUNCTION_URL durch die URL Ihrer randomgen-Funktion.
Ersetzen Sie MULTIPLY_FUNCTION_URL durch die URL Ihrer multiply-Funktion.

Dadurch wird der externe REST-Dienst mit den Cloud Run-Funktionen verknüpft und ein Endergebnis zurückgegeben.

Stellen Sie den geänderten Workflow bereit:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.

Cloud Run-Dienst bereitstellen

Stellen Sie einen Cloud Run-Dienst bereit, der nach dem Erhalt einer HTTP-Anfrage den input aus dem JSON-Text extrahiert, den math.floor berechnet und das Ergebnis zurückgibt.

Erstellen Sie ein Verzeichnis mit dem Namen floor und rufen Sie es auf:
```
mkdir ~/floor
cd ~/floor
```

Erstellen Sie eine Textdatei mit dem Dateinamen app.py, die den folgenden Python-Code enthält:

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)))

Erstellen Sie im selben Verzeichnis eine Dockerfile mit folgendem Inhalt:

# 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

Artifact Registry-Standard-Repository erstellen, in dem Sie Ihr Docker-Container-Image speichern können.
```
gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=${REGION}
```
Ersetzen Sie REPOSITORY durch einen eindeutigen Namen für das Repository.

Erstellen Sie das Container-Image:

export SERVICE_NAME=floor
gcloud builds submit --tag ${REGION}-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}

Stellen Sie das Container-Image in Cloud Run bereit und achten Sie darauf, dass nur authentifizierte Aufrufe akzeptiert werden:

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

Wenn die Dienst-URL angezeigt wird, wurde sie erfolgreich bereitgestellt. Sie müssen diese URL beim Aktualisieren der Workflow-Definition angeben.

Cloud Run-Dienst mit dem Workflow verbinden

Aktualisieren Sie Ihren vorhandenen Workflow und geben Sie die URL für den Cloud Run-Dienst an.

Gehen Sie zurück zum Basisverzeichnis:
```
cd ~
```

Bearbeiten Sie die Quelldatei für Ihren Workflow und ersetzen Sie sie durch folgenden Inhalt:

- randomgen_function:
    call: http.get
    args:
        url: RANDOMGEN_FUNCTION_URL
    result: randomgen_result
- multiply_function:
    call: http.post
    args:
        url: MULTIPLY_FUNCTION_URL
        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}

Ersetzen Sie RANDOMGEN_FUNCTION_URL durch die URL Ihrer randomgen-Funktion.
Ersetzen Sie MULTIPLY_FUNCTION_URL durch die URL Ihrer multiply-Funktion.
Ersetzen Sie CLOUD_RUN_SERVICE_URL durch die URL des Cloud Run-Dienstes.

Dadurch wird der Cloud Run-Dienst im Workflow verbunden. Der Schlüssel auth sorgt dafür, dass ein Authentifizierungstoken an den Aufruf des Cloud Run-Dienstes übergeben wird. Weitere Informationen finden Sie unter Authentifizierte Anfragen von einem Workflow aus ausführen.

Stellen Sie den geänderten Workflow bereit:

gcloud workflows deploy WORKFLOW_NAME \
    --source=workflow.yaml \
    --service-account=${SERVICE_ACCOUNT}@PROJECT_ID.

Abschließenden Workflow ausführen:

gcloud workflows run WORKFLOW_NAME

Die Ausgabe sollte in etwa so aussehen:

result: '{"floorResult":{"body":"4","code":200
  ...
  "logResult":{"body":"4.02535169073515","code":200
  ...
  "multiplyResult":{"body":{"multiplied":56},"code":200
  ...
  "randomResult":{"body":{"random":28},"code":200
  ...
startTime: '2023-11-13T21:22:56.782669001Z'
state: SUCCEEDED

Glückwunsch! Sie haben einen Workflow bereitgestellt und ausgeführt, der eine Reihe von Diensten miteinander verbindet.

Weitere Informationen zur Erstellung komplexerer Workflows mit Ausdrücken, bedingten Sprüngen, Base64-Codierung/-Decodierung, Subworkflows und mehr finden Sie in der Workflow-Syntaxreferenz und in der Standardbibliothek – Übersicht.