Consultez les connecteurs compatibles avec Application Integration.

Insérer des données dans BigQuery à l'aide d'une tâche pour chaque parallélisme

Dans ce tutoriel, vous allez créer une intégration d'application et une sous-intégration pour traiter une série d'enregistrements. Pour chaque enregistrement, l'intégration principale appelle de manière asynchrone la sous-intégration, qui prend les données de chaque enregistrement et les insère en tant que ligne dans une table d'un ensemble de données BigQuery.

Dans ce tutoriel, vous allez effectuer les tâches suivantes :

Avant de commencer

  • Vérifiez que vous avez accès à Application Integration.

  • Procédez comme suit dans votre projet Google Cloud :

    • Attribuez les rôles suivants au compte de service que vous souhaitez utiliser pour créer la connexion :
      • roles/bigquery.dataEditor
      • roles/bigquery.readSessionUser
      • roles/secretmanager.viewer
      • roles/secretmanager.secretAccessor
    • Activez les services suivants :
      • secretmanager.googleapis.com (API Secret Manager)
      • connectors.googleapis.com (API Connectors)

      Si ces services n'ont pas encore été activés pour votre projet, vous êtes invité à les activer lors de la création de la connexion sur la page "Créer une connexion".

Configurer une connexion BigQuery

Commencez par créer la table et l'ensemble de données BigQuery à utiliser dans ce tutoriel. Une fois l'ensemble de données et la table créés, créez une connexion BigQuery. Vous utiliserez cette connexion dans une intégration plus loin dans ce tutoriel.

Configurer un ensemble de données et une table BigQuery

Pour configurer votre ensemble de données et votre table BigQuery, procédez comme suit :

  1. Sur la page Cloud Console, sélectionnez votre projet Google Cloud .
  2. Pour lancer une session Cloud Shell à partir de la console Google Cloud, cliquez sur l'icône Icône Activer Cloud Shell Activer Cloud Shell de la console Cloud. Une session s'ouvre dans le volet inférieur de la console Google Cloud.
  3. Pour activer les API BigQuery, saisissez les commandes suivantes dans votre terminal Cloud Shell : 
    export PROJECT_ID=project_id
export REGION=region
gcloud services enable --project "${PROJECT_ID}" \
    bigquery.googleapis.com \
    bigquerystorage.googleapis.com
     Dans cette commande, remplacez :
    • project_id par l'ID de votre Google Cloud projet.
    • region par la région que vous souhaitez utiliser pour créer votre ensemble de données BigQuery.
  4. Pour créer un ensemble de données BigQuery nommé bq_tutorial, saisissez la commande suivante dans votre terminal Cloud Shell : 
          bq  --project_id ${PROJECT_ID} --location ${REGION} mk bq_tutorial
  5. Pour créer une table BigQuery nommée tutorial, saisissez la commande suivante dans votre terminal Cloud Shell : 
          bq --project_id ${PROJECT_ID} \
        query  \
        --nouse_legacy_sql \
      'create table bq_tutorial.tutorial (
      unique_key STRING NOT NULL,
      created_date STRING,
      closed_date STRING,
      agency STRING,
      agency_name STRING,
      complaint_type STRING,
      descriptor STRING,
      location_type STRING,
      incident_zip STRING,
      incident_address STRING,
      street_name STRING,
      cross_street_1 STRING,
      cross_street_2 STRING,
      intersection_street_1 STRING,
      intersection_street_2 STRING,
      address_type STRING,
      city STRING,
      landmark STRING,
      facility_type STRING,
      status STRING,
      due_date STRING,
      resolution_action_updated_date STRING,
      community_board STRING,
      borough STRING,
      x_coordinate_state_plane STRING,
      y_coordinate_state_plane STRING,
      park_facility_name STRING,
      park_borough STRING,
      school_name STRING,
      school_number STRING,
      school_region STRING,
      school_code STRING,
      school_phone_number STRING,
      school_address STRING,
      school_city STRING,
      school_state STRING,
      school_zip STRING,
      school_not_found STRING,
      school_or_citywide_complaint STRING,
      vehicle_type STRING,
      taxi_company_borough STRING,
      taxi_pick_up_location STRING,
      bridge_highway_name STRING,
      bridge_highway_direction STRING,
      bridge_highway_segment STRING,
      road_ramp STRING,
      garage_lot_name STRING,
      ferry_direction STRING,
      ferry_terminal_name STRING,
      latitude STRING,
      longitude STRING,
      location STRING
      ) '
  6. Verify that your BigQuery table is created.
    1. In the Cloud console page, click the Navigation menu.
    2. In the Analytics section, click BigQuery.
    3. Expand your project and confirm that the bq_tutorial dataset is listed.
    4. Expand the bq_tutorial dataset and confirm that the tutorial table is listed.
    5. Click the documents table to view the schema.

Create a BigQuery connection

Next, you'll create a BigQuery connection. A BigQuery connection lets you insert, read, update and delete rows in a BigQuery table and use the resulting output in an integration. After creating the BigQuery connection, you'll use this connection in an integration later in this tutorial to add rows to the BigQuery table.

To create a BigQuery connection, complete the following steps:

  1. In the Cloud console page, select your Google Cloud project.
  2. Open the connections page.
  3. Click + CREATE NEW to open the Create Connection page.
  4. Configure the connection:
    1. In the Create Connection section, complete the following:
      • Connector: Select BigQuery from the drop down list of available Connectors.
      • Connector version: Select the latest Connector version from the drop down list of available versions.
      • In the Connection Name field, enter a name for the Connection instance. For this tutorial, enter connector-bq-tutorial.
      • Optionally, add a Description of the connection instance.
      • Service Account: Select a service account that has the required roles.
      • Project ID: Enter the ID of the Google Cloud project where the BigQuery data resides.
      • Dataset ID: Enter the ID of the BigQuery dataset that you want to use. For this tutorial, enter bq_tutorial.
      • Optionally, click + ADD LABEL to add a label in the form of a key/value pair.
      • Click Next.
    2. Location: Select a region from where the connection will run. Supported regions for connectors include:

        For the list of all the supported regions, see Locations.

      • Click Next.
    3. Authentication: The BigQuery connection does not require authentication configuration. Click Next.
    4. Review: Review your connection's configuration details. In this section, the connection and authentication details of the new connection are displayed for your review.
  5. Click Create.

Set up a sub-integration

In this tutorial, the sub-integration takes each record sent to it by the main integration and inserts it as a row in the tutorial table in the bq_tutorial dataset.

Create a sub-integration

To create the sub-integration, complete the following steps:

  1. In the Google Cloud console, go to the Application Integration page.

    Go to Application Integration

  2. In the navigation menu, click Integrations. The Integrations page appears.
  3. Click Create integration.
  4. In the Create Integration dialog, do the following:
    • Enter a name, for example, enter Process-each-record
    • Optionally, enter a description. For example, enter API Trigger to process each record (sub-integration)
    • Select the region where you want to create your integration.
  5. Click Create to open the integration editor.

Add an API Trigger

To add an API Trigger to the integration, do the following:

  1. In the integration editor, select Add a task/trigger > Triggers to display a list of available triggers.
  2. Drag the API Trigger element to the integration editor.

Add a Data Mapping task

To add a Data Mapping task in the integration, complete the following steps:

  1. Select +Add a task/trigger > Tasks in the integration editor to display the list of available tasks.
  2. Drag the Data Mapping element to the integration editor.

Configure the BigQuery connection

Now you are ready to use the BigQuery connection that you created earlier in the sub-integration. To configure the BigQuery connection in this integration, complete the following steps:

  1. Select +Add a task/trigger > Tasks in the integration editor to display the list of available tasks.
  2. Drag the Connectors element to the integration editor.
  3. Click the Connectors task element on the designer to view the task configuration pane.
  4. Click the edit icon on the right panel and update the Label to Insert row to BigQuery.
  5. Click Configure task.

    The Configure connector task dialog appears.

  6. In the Configure connector task dialog, do the following:
    1. Select the connection region where you created your BigQuery connection.
    2. Select the BigQuery connection that you want to use. For this tutorial, select connector-bq-tutorial.
    3. Once a connection is chosen, the Type column appears. Select Entities and then tutorial from the list of available entities.
    4. Once a type is chosen, the Operation column appears. Select Create.
    5. Click Done to complete the connection configuration and close the dialog.

Connect the integration elements

Next, add edge connections to connect the API Trigger to the Data Mapping task and the Data Mapping task to the Connectors task. An edge connection is a connection between any two elements in an integration. For more information on edges and edge conditions, see Edges.

To add the edge connections, complete the following steps:

  1. Click the Fork control point at the bottom of the API Trigger element. Drag and drop the edge connection at the Join control point at the top of the Data Mapping element.
  2. Click the Fork control point at the bottom of the Data Mapping element. Drag and drop the edge connection at the Join control point at the top of the Connectors element.

Configure the Data Mapping task

To configure the Data Mapping task, complete the following steps:

  1. In the integration editor, click the Data Mapping task to view the task configuration pane.
  2. Click Open Data Mapping Editor.
  3. In the Data Mapping Editor, click Add to add a new variable.
  4. In the Create Variable dialog, enter the following information:
    • Name: Enter record.
    • Data Type: Select JSON.
    • Schema: Select Infer from a sample JSON payload. Enter the following sample JSON payload: 
                  {
              "unique_key":"304271",
              "created_date":"02/06/2007 12:00:00 AM",
              "closed_date":"03/01/2007 12:00:00 AM",
              "agency":"TLC",
              "agency_name":"Taxi and Limousine Commission",
              "complaint_type":"Taxi Complaint",
              "descriptor":"Driver Complaint",
              "location_type":"Street",
              "incident_zip":"10001",
              "incident_address":"",
              "street_name":"",
              "cross_street_1":"",
              "cross_street_2":"",
              "intersection_street_1":"WEST 29 STREET",
              "intersection_street_2":"7 AVENUE",
              "address_type":"INTERSECTION",
              "city":"NEW YORK",
              "landmark":"",
              "facility_type":"N/A",
              "status":"Closed",
              "due_date":"02/28/2007 12:00:00 AM",
              "resolution_action_updated_date":"03/01/2007 12:00:00 AM",
              "community_board":"05 MANHATTAN",
              "borough":"MANHATTAN",
              "x_coordinate_state_plane":"986215",
              "y_coordinate_state_plane":"211740",
              "park_facility_name":"",
              "park_borough":"MANHATTAN",
              "school_name":"",
              "school_number":"",
              "school_region":"",
              "school_code":"",
              "school_phone_number":"",
              "school_address":"",
              "school_city":"",
              "school_state":"",
              "school_zip":"",
              "school_not_found":"",
              "school_or_citywide_complaint":"",
              "vehicle_type":"",
              "taxi_company_borough":"",
              "taxi_pick_up_location":"Other",
              "bridge_highway_name":"",
              "bridge_highway_direction":"",
              "road_ramp":"",
              "bridge_highway_segment":"",
              "garage_lot_name":"",
              "ferry_direction":"",
              "ferry_terminal_name":"",
              "latitude":"40.74785373937869",
              "longitude":"-73.99290823133913",
              "location":"(40.74785373937869, -73.99290823133913)"
            }
    • Cliquez sur Créer.
    • Une fois la variable créée, procédez comme suit dans l'éditeur de mappage de données :
      • Faites glisser la nouvelle variable record dans la colonne Entrée.
      • Faites glisser la variable connectorInputPayload vers la colonne Sortie.
    • Fermez l'éditeur de mappage de données pour revenir à l'éditeur d'intégration.

Publier la sous-intégration

Pour publier la sous-intégration, cliquez sur Publier dans l'éditeur d'intégration.

Configurer l'intégration principale

Dans cette section, vous allez configurer l'intégration principale, qui utilise une tâche Pour chaque parallélisme pour traiter chaque enregistrement. Cette intégration principale appelle ensuite la sous-intégration pour chaque enregistrement.

Créer l'intégration principale

Pour créer l'intégration principale, procédez comme suit :

  1. Dans la console Google Cloud, accédez à la page Application Integration.

    Accéder à Application Integration

  2. Dans le menu de navigation, cliquez sur Intégrations. La page Integrations s'affiche.
  3. Cliquez sur Créer une intégration.
  4. Dans la boîte de dialogue Créer une intégration, procédez comme suit :
    • Saisissez un nom. Par exemple, saisissez process-records.
    • (Facultatif) Saisissez une description. Par exemple, saisissez Déclencheur d'API pour traiter chaque enregistrement (sous-intégration).
    • Sélectionnez la région dans laquelle vous souhaitez créer votre intégration.
  5. Cliquez sur Créer pour ouvrir l'éditeur d'intégration.

Ajouter un déclencheur d'API

Pour ajouter un déclencheur d'API à l'intégration, procédez comme suit :

  1. Dans l'éditeur d'intégration, sélectionnez Ajouter une tâche/déclencheur > Déclencheurs pour afficher la liste des déclencheurs disponibles.
  2. Faites glisser l'élément Déclencheur d'API vers l'éditeur d'intégration.

Ajouter une tâche pour chaque tâche en parallèle

Pour ajouter une tâche pour chaque parallèle dans l'intégration, procédez comme suit :

  1. Sélectionnez + Ajouter une tâche/un déclencheur > Tâches dans l'éditeur d'intégration pour afficher la liste des tâches disponibles.
  2. Faites glisser l'élément Pour chaque parallèle dans l'éditeur d'intégration.

Connecter les éléments d'intégration

Ensuite, ajoutez une connexion périphérique pour connecter le déclencheur d'API à la tâche pour chaque parallèle.

Pour ajouter la connexion périphérique, cliquez sur le point de contrôle Duplication en bas de l'élément "Déclencheur d'API". Faites glisser la connexion périphérique au niveau du point de contrôle Jointure en haut de l'élément de tâche "Pour chaque parallèle".

Configurer la tâche pour chaque parallèle

Pour configurer la tâche "Pour chaque parallèle", procédez comme suit :

  1. Dans l'éditeur d'intégration, cliquez sur la tâche Pour chaque parallèle pour afficher le volet de configuration de la tâche.
  2. Sous Sélection de tableau > Liste à itérer, cliquez sur Ajouter une variable pour ajouter une nouvelle variable.
  3. Dans la boîte de dialogue Créer une variable, saisissez les informations suivantes :
    • Nom : saisissez records.
    • Type de données : sélectionnez JSON.
    • Schéma : sélectionnez Inférer à partir d'un exemple de charge utile JSON. Saisissez l'exemple de charge utile JSON suivant : 
                    [{
                "unique_key":"304271",
                "created_date":"02/06/2007 12:00:00 AM",
                "closed_date":"03/01/2007 12:00:00 AM",
                "agency":"TLC",
                "agency_name":"Taxi and Limousine Commission",
                "complaint_type":"Taxi Complaint",
                "descriptor":"Driver Complaint",
                "location_type":"Street",
                "incident_zip":"10001",
                "incident_address":"",
                "street_name":"",
                "cross_street_1":"",
                "cross_street_2":"",
                "intersection_street_1":"WEST 29 STREET",
                "intersection_street_2":"7 AVENUE",
                "address_type":"INTERSECTION",
                "city":"NEW YORK",
                "landmark":"",
                "facility_type":"N/A",
                "status":"Closed",
                "due_date":"02/28/2007 12:00:00 AM",
                "resolution_action_updated_date":"03/01/2007 12:00:00 AM",
                "community_board":"05 MANHATTAN",
                "borough":"MANHATTAN",
                "x_coordinate_state_plane":"986215",
                "y_coordinate_state_plane":"211740",
                "park_facility_name":"",
                "park_borough":"MANHATTAN",
                "school_name":"",
                "school_number":"",
                "school_region":"",
                "school_code":"",
                "school_phone_number":"",
                "school_address":"",
                "school_city":"",
                "school_state":"",
                "school_zip":"",
                "school_not_found":"",
                "school_or_citywide_complaint":"",
                "vehicle_type":"",
                "taxi_company_borough":"",
                "taxi_pick_up_location":"Other",
                "bridge_highway_name":"",
                "bridge_highway_direction":"",
                "road_ramp":"",
                "bridge_highway_segment":"",
                "garage_lot_name":"",
                "ferry_direction":"",
                "ferry_terminal_name":"",
                "latitude":"40.74785373937869",
                "longitude":"-73.99290823133913",
                "location":"(40.74785373937869, -73.99290823133913)"
              }]
  4. Cliquez sur Créer.
  5. Dans la section Détails de la sous-intégration, saisissez les informations suivantes :
    • ID de déclencheur d'API : sélectionnez l'élément de déclencheur d'API dans la sous-intégration. Par exemple, sélectionnez Process-each-record_API_1.
    • Stratégie d'exécution : sélectionnez ASYNC.
    • Sélectionnez Exécuter une seule intégration.
  6. Dans la section À chaque exécution, sous Où mapper les éléments de tableau, saisissez le nom de la variable dans la tâche de mappage des données dans la sous-intégration. Dans ce cas, saisissez enregistrement. Les variables de sous-intégration ne sont listées que pour les intégrations publiées. Si les variables ne sont pas listées, actualisez la page, car il faut un certain temps pour qu'elles soient visibles après la publication de la sous-intégration.

Publier l'intégration principale

Pour publier l'intégration principale, cliquez sur Publier dans l'éditeur d'intégration.

Tester votre intégration

Pour tester votre intégration, procédez comme suit :

  1. Téléchargez des exemples de données dans Cloud Shell :
    1. Pour lancer une session Cloud Shell à partir de la console Google Cloud, cliquez sur l'icône Icône Activer Cloud Shell Activer Cloud Shell de la console Cloud. Une session s'ouvre dans le volet inférieur de la console Cloud.
    2. Saisissez la commande suivante dans votre terminal Cloud Shell : 
      wget https://raw.githubusercontent.com/GoogleCloudPlatform/application-integration-samples/main/assets/bq-sample-dataset.json
    3. Pour vérifier que les exemples de données ont été téléchargés, saisissez la commande suivante dans votre terminal Cloud Shell : 
      ls -la bq-sample-dataset.json
       Le fichier téléchargé est répertorié dans le terminal Cloud Shell.
  2. Pour sélectionner trois entrées aléatoires de l'exemple d'ensemble de données et les stocker de manière à pouvoir les transmettre à l'intégration, saisissez les commandes suivantes dans votre terminal Cloud Shell: 
    AUTH=$(gcloud auth print-access-token)
export SAMPLE_DOCS=$(jq $(r=$((RANDOM % 1000)) ; echo ".[$r:$((r + 3))]") < bq-sample-dataset.json | jq -Rs '.')
            
generate_post_data()
  {
    cat <<EOF
      {
        "triggerId": "api_trigger/process-records_API_1",
        "inputParameters": 
          {
            "records": 
              {
                "jsonValue": $SAMPLE_DOCS
              }
          }
      }
      EOF
  }
  3. Pour démarrer le test, saisissez la commande suivante dans votre terminal Cloud Shell: 
    curl -X POST \
  https://integrations.googleapis.com/v1/projects/project_id/locations/region/integrations/process-records:execute \
  -H "Authorization: Bearer $AUTH" \
  -H "Content-Type: application/json" \
  -d "$(generate_post_data)"
     Dans cette commande, remplacez :
    • project_id par l'ID de votre Google Cloud projet.
    • region par la région dans laquelle vous avez créé votre intégration.
    Cette commande appelle l'intégration principale et lui transmet les entrées de l'exemple d'ensemble de données. L'intégration principale transmet ensuite chaque entrée à la sous-intégration, qui ajoute les données sous forme de ligne dans la table BigQuery.
  4. Pour vérifier que votre table BigQuery contient désormais ces enregistrements, procédez comme suit :
    1. Sur la page console Cloud, cliquez sur le menu de navigation .
    2. Dans la section Analyse, cliquez sur BigQuery.
    3. Développez votre projet, puis cliquez sur l'ensemble de données bq_tutorial.
    4. Développez l'ensemble de données bq_tutorial et cliquez sur la table tutorial.
    5. Cliquez sur l'onglet Explorateur de tables pour afficher les enregistrements insérés.

Étapes suivantes

Essayez de créer des intégrations avec d'autres connecteurs. Pour obtenir la liste de tous les connecteurs compatibles, consultez la Documentation de référence sur les connecteurs.