Esta página foi traduzida pela API Cloud Translation.
Switch to English

Amostras de conectores

Nesta página, você verá exemplos de fluxos de trabalho que demonstram o uso de conectores em um fluxo de trabalho para acessar recursos em outros produtos do Google Cloud.

Autenticação

Ao usar um conector para acessar recursos em outro produto do Google Cloud, seu fluxo de trabalho precisa estar associado a uma conta de serviço que tenha privilégios suficientes para acessar esses recursos. Para saber mais sobre como conceder papéis a contas de serviço, consulte Como conceder, alterar e revogar o acesso a recursos. Para saber como alterar a conta de serviço associada a um fluxo de trabalho, consulte como atualizar um fluxo de trabalho. Para mais informações sobre autenticação, consulte Como fazer solicitações autenticadas de dentro de um fluxo de trabalho.

Cada amostra desta página fornece orientação sobre um papel adequado que concederá privilégios suficientes para realizar as tarefas realizadas por ela.

Como usar estas amostras

Para usar essas amostras, substitua os valores das variáveis na etapa initVariables pelos seus próprios valores, conforme necessário. ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")} extrai o ID do projeto do Google Cloud e não precisa ser substituído.

Amostras do Compute Engine

Os exemplos a seguir demonstram o uso de um fluxo de trabalho para se conectar a uma instância do Compute Engine.

A conta de serviço associada ao fluxo de trabalho precisa receber o papel de Administrador de instâncias do Compute (v1) do IAM.

Interromper uma instância

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}"
    }
  }
]

Como iniciar uma instância

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}"
    }
  }
]

Amostra do Pub/Sub

O exemplo a seguir demonstra o uso de um fluxo de trabalho para publicar uma mensagem em um tópico com o Pub/Sub.

A conta de serviço associada ao fluxo de trabalho precisa receber o papel de IAM de editor do Pub/Sub.

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}"
    }
  }
]

Amostra do Gerenciador de secrets

Na amostra a seguir, demonstramos como usar um fluxo de trabalho para acessar um secret no Gerenciador de secrets.

A conta de serviço associada ao fluxo de trabalho precisa receber o papel de acessor de secret do Secret Manager.

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))}"
        }
      ]
    }
  }
]

Amostras do Firestore

Os exemplos a seguir demonstram o uso de um fluxo de trabalho para se conectar a uma instância do Firestore.

A conta de serviço associada ao fluxo de trabalho precisa receber o papel de usuário do Cloud Datastore.

Como ler um documento do 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}"
    }
  }
]

Como criar ou atualizar um documento no 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}"
    }
  }
]

Amostra de tarefas

O exemplo a seguir demonstra como usar um fluxo de trabalho para criar tarefas no Tarefas.

A conta de serviço associada ao fluxo de trabalho precisa receber o papel de Enfileerador do Cloud Tasks.

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}"
    }
  }
]