Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Connectors – Beispiele

Auf dieser Seite finden Sie Beispielworkflows, die die Verwendung von Connectors in einem Workflow zeigen, um auf Ressourcen in anderen Google Cloud-Produkten zuzugreifen.

Authentication

Wenn Sie einen Connector verwenden, um auf Ressourcen in einem anderen Google Cloud-Produkt zuzugreifen, muss Ihr Workflow mit einem Dienstkonto verknüpft sein, das ausreichende Berechtigungen für den Zugriff auf diese Ressourcen hat. Weitere Informationen zum Zuweisen von Rollen für Dienstkonten finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen. Informationen zum Ändern des mit einem Workflow verknüpften Dienstkontos finden Sie unter Workflow aktualisieren. Weitere Informationen zur Authentifizierung finden Sie unter Authentifizierte Anfragen innerhalb eines Workflows ausführen.

Jedes Beispiel auf dieser Seite enthält eine Anleitung für eine geeignete Rolle, die ausreichende Berechtigungen gewährt, um die Aufgaben dieser Stichprobe auszuführen.

Beispiele verwenden

Wenn Sie diese Beispiele verwenden möchten, ersetzen Sie die Werte für die Variablen im Schritt initVariables durch Ihre eigenen Werte. ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")} ruft Ihre Google Cloud-Projekt-ID ab und muss nicht ersetzt werden.

Compute Engine-Beispiele

Die folgenden Beispiele zeigen die Verwendung eines Workflows zum Herstellen einer Verbindung zu einer Compute Engine-Instanz.

Dem mit dem Workflow verknüpften Dienstkonto muss die IAM-Rolle "Compute-Instanzadministrator" (v1) zugewiesen sein.

Instanz beenden

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - instance: "myinstance1"
      - zone: "us-central1-a"
- stopVM:
    try:
      call: googleapis.compute.v1.instances.stop
      args:
        project: ${project}
        instance: ${instance}
        zone: ${zone}
      result: stopVMResult
    except:
      as: e
      steps:
        - handleComputeEngineError:
            switch:
              - condition: ${e.code == 404}
                raise: "Compute Engine instance not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Compute Engine"
        - unhandledException:
            raise: ${e}
- last:
    return: ${stopVMResult}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "instance": "myinstance1"
        },
        {
          "zone": "us-central1-a"
        }
      ]
    }
  },
  {
    "stopVM": {
      "try": {
        "call": "googleapis.compute.v1.instances.stop",
        "args": {
          "project": "${project}",
          "instance": "${instance}",
          "zone": "${zone}"
        },
        "result": "stopVMResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleComputeEngineError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Compute Engine instance not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Compute Engine"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${stopVMResult}"
    }
  }
]

Instanz starten

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - instance: "myinstance1"
      - zone: "us-central1-a"
- startVM:
    try:
      call: googleapis.compute.v1.instances.start
      args:
        project: ${project}
        instance: ${instance}
        zone: ${zone}
      result: startVMResult
    except:
      as: e
      steps:
        - handleComputeEngineError:
            switch:
              - condition: ${e.code == 404}
                raise: "Compute Engine instance not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Compute Engine"
        - unhandledException:
            raise: ${e}
- last:
    return: ${startVMResult}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "instance": "myinstance1"
        },
        {
          "zone": "us-central1-a"
        }
      ]
    }
  },
  {
    "startVM": {
      "try": {
        "call": "googleapis.compute.v1.instances.start",
        "args": {
          "project": "${project}",
          "instance": "${instance}",
          "zone": "${zone}"
        },
        "result": "startVMResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleComputeEngineError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Compute Engine instance not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Compute Engine"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${startVMResult}"
    }
  }
]

Pub/Sub-Beispiel

Im folgenden Beispiel wird gezeigt, wie mit einem Workflow eine Nachricht für ein Thema mit Pub/Sub veröffentlicht wird.

Dem mit dem Workflow verknüpften Dienstkonto muss die IAM-Rolle "Pub/Sub-Publisher" zugewiesen werden.

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - topic: "mytopic1"
      - message: "Hello world!"
- publish:
    try:
      call: googleapis.pubsub.v1.projects.topics.publish
      args:
        topic: ${"projects/" + project + "/topics/" + topic}
        body:
          messages:
            - data: ${base64.encode(text.encode(message))}
      result: publishResult
    except:
      as: e
      steps:
        - handlePubSubError:
            switch:
              - condition: ${e.code == 404}
                raise: "PubSub Topic not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to PubSub"
        - unhandledException:
            raise: ${e}
- last:
    return: ${publishResult}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "topic": "mytopic1"
        },
        {
          "message": "Hello world!"
        }
      ]
    }
  },
  {
    "publish": {
      "try": {
        "call": "googleapis.pubsub.v1.projects.topics.publish",
        "args": {
          "topic": "${\"projects/\" + project + \"/topics/\" + topic}",
          "body": {
            "messages": [
              {
                "data": "${base64.encode(text.encode(message))}"
              }
            ]
          }
        },
        "result": "publishResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handlePubSubError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "PubSub Topic not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to PubSub"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${publishResult}"
    }
  }
]

Beispiel für Secret Manager

Im folgenden Beispiel wird gezeigt, wie mit einem Workflow auf ein Secret im Secret Manager zugegriffen wird.

Dem mit dem Workflow verknüpften Dienstkonto muss die Rolle "Secret Manager Secret Accessor" zugewiesen sein.

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_NUMBER")}
      - secret: "mysecret"
      - version: 1
- getSecret:
    try:
      call: googleapis.secretmanager.v1.projects.secrets.versions.access
      args:
        name: ${"projects/" + project + "/secrets/" + secret + "/versions/" + string(version)}
      result: secretResult
    except:
      as: e
      steps:
        - handleSecretManagerError:
            switch:
              - condition: ${e.code == 404}
                raise: "Secret not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Secret Manager"
        - unhandledException:
            raise: ${e}
- storeSecret:
    assign:
      - secretValue: ${text.decode(base64.decode(secretResult.payload.data))}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_NUMBER\")}"
        },
        {
          "secret": "mysecret"
        },
        {
          "version": 1
        }
      ]
    }
  },
  {
    "getSecret": {
      "try": {
        "call": "googleapis.secretmanager.v1.projects.secrets.versions.access",
        "args": {
          "name": "${\"projects/\" + project + \"/secrets/\" + secret + \"/versions/\" + string(version)}"
        },
        "result": "secretResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleSecretManagerError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Secret not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Secret Manager"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "storeSecret": {
      "assign": [
        {
          "secretValue": "${text.decode(base64.decode(secretResult.payload.data))}"
        }
      ]
    }
  }
]

Firestore-Beispiele

Die folgenden Beispiele zeigen, wie ein Workflow für die Verbindung mit einer Firestore-Instanz verwendet wird.

Dem mit dem Workflow verknüpften Dienstkonto muss die Rolle "Cloud Datastore-Nutzer" zugewiesen sein.

Lesen eines Dokuments aus Firestore

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - collection: "peopleDatabase"
      - document: "smith.j"
- readFromFirestore:
    try:
      call: googleapis.firestore.v1.projects.databases.documents.get
      args:
        name: ${"projects/"+project+"/databases/(default)/documents/"+collection+"/"+document}
      result: readResult
    except:
      as: e
      steps:
        - handleFirestoreReadError:
            switch:
              - condition: ${e.code == 404}
                raise: "Firestore database or document not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Firestore"
        - unhandledException:
            raise: ${e}
- last:
    return: ${readResult.fields}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "collection": "peopleDatabase"
        },
        {
          "document": "smith.j"
        }
      ]
    }
  },
  {
    "readFromFirestore": {
      "try": {
        "call": "googleapis.firestore.v1.projects.databases.documents.get",
        "args": {
          "name": "${\"projects/\"+project+\"/databases/(default)/documents/\"+collection+\"/\"+document}"
        },
        "result": "readResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleFirestoreReadError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Firestore database or document not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Firestore"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${readResult.fields}"
    }
  }
]

Erstellen oder Aktualisieren eines Dokuments in Firestore

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - collection: "peopleDatabase"
      - document: "smith.j"
      - valuesToWrite:
          FirstName:
            stringValue: "John"
          LastName:
            stringValue: "Smith"
          Age:
            integerValue: 32
- writeToFirestore:
    try:
      call: googleapis.firestore.v1.projects.databases.documents.patch
      args:
        name: ${"projects/"+project+"/databases/(default)/documents/"+collection+"/"+document}
        body:
          fields: ${valuesToWrite}
      result: writeResult
    except:
      as: e
      steps:
        - handleFirestoreWriteError:
            switch:
              - condition: ${e.code == 404}
                raise: "Firestore database or document not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Firestore"
        - unhandledException:
            raise: ${e}
- last:
    return: ${writeResult.name}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "collection": "peopleDatabase"
        },
        {
          "document": "smith.j"
        },
        {
          "valuesToWrite": {
            "FirstName": {
              "stringValue": "John"
            },
            "LastName": {
              "stringValue": "Smith"
            },
            "Age": {
              "integerValue": 32
            }
          }
        }
      ]
    }
  },
  {
    "writeToFirestore": {
      "try": {
        "call": "googleapis.firestore.v1.projects.databases.documents.patch",
        "args": {
          "name": "${\"projects/\"+project+\"/databases/(default)/documents/\"+collection+\"/\"+document}",
          "body": {
            "fields": "${valuesToWrite}"
          }
        },
        "result": "writeResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleFirestoreWriteError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Firestore database or document not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Firestore"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${writeResult.name}"
    }
  }
]

Tasks-Beispiel

Das folgende Beispiel zeigt die Verwendung eines Workflows zum Erstellen von Aufgaben in Tasks.

Dem mit dem Workflow verknüpften Dienstkonto muss die Rolle "Cloud Tasks Enquerer" zugewiesen werden.

YAML

- initVariables:
    assign:
      - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
      - location: ${sys.get_env("GOOGLE_CLOUD_LOCATION")}
      - queue: "testqueue"
      - taskURL: "https://somewhere.com/apiendpoint"
      - method: "POST"
      - body: "Hello world!"
- startTask:
    try:
      call: googleapis.cloudtasks.v2.projects.locations.queues.tasks.create
      args:
        parent: ${"projects/" + project + "/locations/" + location + "/queues/" + queue}
        body:
          task:
            httpRequest:
              body: ${base64.encode(text.encode(body))}
              httpMethod: ${method}
              url: ${taskURL}
            scheduleTime:
              seconds: int(sys.now() + 60*60*24)
      result: taskResult
    except:
      as: e
      steps:
        - handleTasksError:
            switch:
              - condition: ${e.code == 404}
                raise: "Tasks queue not found"
              - condition: ${e.code == 403}
                raise: "Error authenticating to Cloud Tasks"
        - unhandledException:
            raise: ${e}

- last:
    return: ${taskResult.body}

JSON

[
  {
    "initVariables": {
      "assign": [
        {
          "project": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
        },
        {
          "location": "${sys.get_env(\"GOOGLE_CLOUD_LOCATION\")}"
        },
        {
          "queue": "testqueue"
        },
        {
          "taskURL": "https://somewhere.com/apiendpoint"
        },
        {
          "method": "POST"
        },
        {
          "body": "Hello world!"
        }
      ]
    }
  },
  {
    "startTask": {
      "try": {
        "call": "googleapis.cloudtasks.v2.projects.locations.queues.tasks.create",
        "args": {
          "parent": "${\"projects/\" + project + \"/locations/\" + location + \"/queues/\" + queue}",
          "body": {
            "task": {
              "httpRequest": {
                "body": "${base64.encode(text.encode(body))}",
                "httpMethod": "${method}",
                "url": "${taskURL}"
              },
              "scheduleTime": {
                "seconds": "int(sys.now() + 60*60*24)"
              }
            }
          }
        },
        "result": "taskResult"
      },
      "except": {
        "as": "e",
        "steps": [
          {
            "handleTasksError": {
              "switch": [
                {
                  "condition": "${e.code == 404}",
                  "raise": "Tasks queue not found"
                },
                {
                  "condition": "${e.code == 403}",
                  "raise": "Error authenticating to Cloud Tasks"
                }
              ]
            }
          },
          {
            "unhandledException": {
              "raise": "${e}"
            }
          }
        ]
      }
    }
  },
  {
    "last": {
      "return": "${taskResult.body}"
    }
  }
]