Librerie client di Analytics Hub

Questa pagina mostra come iniziare a utilizzare le librerie client di Cloud per l'API Analytics Hub. Le librerie client semplificano l'accesso alle API di Google Cloud da un linguaggio supportato. Sebbene sia possibile utilizzare direttamente le API Google Cloud effettuando richieste non elaborate al server, le librerie client offrono semplificazioni che riducono notevolmente la quantità di codice da scrivere.

Scopri di più sulle librerie client di Cloud e sulle librerie client precedenti delle API di Google nella pagina Spiegazione delle librerie client.

installa la libreria client

C#GoJavaNode.jsPHPPythonRuby
Install-Package Google.Cloud.BigQuery.AnalyticsHub.V1 -Pre

Per ulteriori informazioni, consulta la sezione Configurazione di un ambiente di sviluppo C#.

go get cloud.google.com/go/bigquery

Per saperne di più, consulta la pagina Configurazione di un ambiente di sviluppo Go.

Per ulteriori informazioni, consulta la sezione Configurazione di un ambiente di sviluppo Java.

npm install @google-cloud/bigquery-data-exchange

Per ulteriori informazioni, consulta la sezione Configurare un ambiente di sviluppo Node.js.

composer require google/cloud-bigquery-analyticshub

Per ulteriori informazioni, consulta Utilizzo di PHP su Google Cloud.

pip install --upgrade google-cloud-bigquery-analyticshub

Per ulteriori informazioni, consulta la sezione Configurazione di un ambiente di sviluppo Python.

gem install google-cloud-bigquery-analytics_hub-v1

Per ulteriori informazioni, consulta la sezione Configurare un ambiente di sviluppo Ruby.

Configura l'autenticazione

Per autenticare le chiamate alle API Google Cloud, le librerie client supportano le credenziali predefinite dell'applicazione (ADC). Le librerie cercano le credenziali in una serie di località definite e le utilizzano per autenticare le richieste all'API. Con ADC, puoi rendere disponibili le credenziali per la tua applicazione in diversi ambienti, come lo sviluppo o la produzione locale, senza dover modificare il codice dell'applicazione.

Per gli ambienti di produzione, il modo in cui configuri ADC dipende dal servizio e dal contesto. Per ulteriori informazioni, vedi Configurare le credenziali predefinite dell'applicazione.

Per un ambiente di sviluppo locale, puoi configurare ADC con le credenziali associate al tuo Account Google:

  1. Installa e inizializza gcloud CLI.

    Quando inizializza gcloud CLI, assicurati di specificare un progetto Google Cloud in cui disponi dell'autorizzazione per accedere alle risorse necessarie alla tua applicazione.

  2. Configura ADC:

    gcloud auth application-default login

    Viene visualizzata una schermata di accesso. Dopo aver eseguito l'accesso, le credenziali vengono archiviate nel file delle credenziali locali utilizzato da ADC.

Utilizzare la libreria client

L'esempio seguente mostra alcune interazioni di base con Analytics Hub.

GoNode.js
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


// The analyticshub quickstart application demonstrates usage of the
// Analytics hub API by creating an example data exchange and listing.
package main

import (
        "context"
        "flag"
        "fmt"
        "log"

        dataexchange "cloud.google.com/go/bigquery/dataexchange/apiv1beta1"
        dataexchangepb "google.golang.org/genproto/googleapis/cloud/bigquery/dataexchange/v1beta1"
        "google.golang.org/grpc/codes"
        "google.golang.org/grpc/status"
)

func main() {

        // Define the command line flags for controlling the behavior of this quickstart.
        var (
                projectID            = flag.String("project_id", "", "Cloud Project ID, used for session creation.")
                location             = flag.String("location", "US", "BigQuery location used for interactions.")
                exchangeID           = flag.String("exchange_id", "ExampleDataExchange", "identifier of the example data exchange")
                listingID            = flag.String("listing_id", "ExampleDataExchange", "identifier of the example data exchange")
                exampleDatasetSource = flag.String("dataset_source", "", "dataset source in the form projects/myproject/datasets/mydataset")
                delete               = flag.Bool("delete_exchange", true, "delete exchange at the end of quickstart")
        )
        flag.Parse()
        // Perform simple validation of the specified flags.
        if *projectID == "" {
                log.Fatal("empty --project_id specified, please provide a valid project ID")
        }
        if *exampleDatasetSource == "" {
                log.Fatalf("empty --dataset_source specified, please provide in the form \"projects/myproject/datasets/mydataset\"")
        }

        // Instantiate the client.
        ctx := context.Background()
        dataExchClient, err := dataexchange.NewAnalyticsHubClient(ctx)
        if err != nil {
                log.Fatalf("NewClient: %v", err)
        }
        defer dataExchClient.Close()

        // Then, create the data exchange (or return information about one already bearing the example name), and
        // print information about it.
        exchange, err := createOrGetDataExchange(ctx, dataExchClient, *projectID, *location, *exchangeID)
        if err != nil {
                log.Fatalf("failed to get information about the exchange: %v", err)
        }
        fmt.Printf("\nData Exchange Information\n")
        fmt.Printf("Exchange Name: %s\n", exchange.GetName())
        if desc := exchange.GetDescription(); desc != "" {
                fmt.Printf("Exchange Description: %s", desc)
        }

        // Finally, create a listing within the data exchange and print information about it.
        listing, err := createListing(ctx, dataExchClient, *projectID, *location, *exchangeID, *listingID, *exampleDatasetSource)
        if err != nil {
                log.Fatalf("failed to create the listing within the exchange: %v", err)
        }
        fmt.Printf("\n\nListing Information\n")
        fmt.Printf("Listing Name: %s\n", listing.GetName())
        if desc := listing.GetDescription(); desc != "" {
                fmt.Printf("Listing Description: %s\n", desc)
        }
        fmt.Printf("Listing State: %s\n", listing.GetState().String())
        if source := listing.GetSource(); source != nil {
                if dsSource, ok := source.(*dataexchangepb.Listing_BigqueryDataset); ok && dsSource.BigqueryDataset != nil {
                        if dataset := dsSource.BigqueryDataset.GetDataset(); dataset != "" {
                                fmt.Printf("Source is a bigquery dataset: %s", dataset)
                        }
                }
        }
        // Optionally, delete the data exchange at the end of the quickstart to clean up the resources used.
        if *delete {
                fmt.Printf("\n\n")
                if err := deleteDataExchange(ctx, dataExchClient, *projectID, *location, *exchangeID); err != nil {
                        log.Fatalf("failed to delete exchange: %v", err)
                }
                fmt.Printf("Exchange projects/%s/locations/%s/dataExchanges/%s was deleted.\n", *projectID, *location, *exchangeID)
        }
        fmt.Printf("\nQuickstart completed.\n")
}

// createOrGetDataExchange creates an example data exchange, or returns information about the exchange already bearing
// the example identifier.
func createOrGetDataExchange(ctx context.Context, client *dataexchange.AnalyticsHubClient, projectID, location, exchangeID string) (*dataexchangepb.DataExchange, error) {
        req := &dataexchangepb.CreateDataExchangeRequest{
                Parent:         fmt.Sprintf("projects/%s/locations/%s", projectID, location),
                DataExchangeId: exchangeID,
                DataExchange: &dataexchangepb.DataExchange{
                        DisplayName:    "Example Data Exchange",
                        Description:    "Exchange created as part of an API quickstart",
                        PrimaryContact: "",
                        Documentation:  "https://link.to.optional.documentation/",
                },
        }

        resp, err := client.CreateDataExchange(ctx, req)
        if err != nil {
                // We'll handle one specific error case specially, the case of the exchange already existing.  In this instance,
                // we'll issue a second request to fetch the exchange information for the already present exchange and return it.
                if code := status.Code(err); code == codes.AlreadyExists {
                        getReq := &dataexchangepb.GetDataExchangeRequest{
                                Name: fmt.Sprintf("projects/%s/locations/%s/dataExchanges/%s", projectID, location, exchangeID),
                        }
                        resp, err = client.GetDataExchange(ctx, getReq)
                        if err != nil {
                                return nil, fmt.Errorf("error getting dataExchange: %w", err)
                        }
                        return resp, nil
                }
                // For all other cases, return the error from creation request.
                return nil, err
        }
        return resp, nil
}

// createListing creates an example listing within the specified exchange using the provided source dataset.
func createListing(ctx context.Context, client *dataexchange.AnalyticsHubClient, projectID, location, exchangeID, listingID, sourceDataset string) (*dataexchangepb.Listing, error) {
        req := &dataexchangepb.CreateListingRequest{
                Parent:    fmt.Sprintf("projects/%s/locations/%s/dataExchanges/%s", projectID, location, exchangeID),
                ListingId: listingID,
                Listing: &dataexchangepb.Listing{
                        DisplayName: "Example Exchange Listing",
                        Description: "Example listing created as part of an API quickstart",
                        Categories: []dataexchangepb.Listing_Category{
                                dataexchangepb.Listing_CATEGORY_OTHERS,
                        },
                        Source: &dataexchangepb.Listing_BigqueryDataset{
                                BigqueryDataset: &dataexchangepb.Listing_BigQueryDatasetSource{
                                        Dataset: sourceDataset,
                                },
                        },
                },
        }
        return client.CreateListing(ctx, req)
}

// deleteDataExchange deletes a data exchange.
func deleteDataExchange(ctx context.Context, client *dataexchange.AnalyticsHubClient, projectID, location, exchangeID string) error {
        req := &dataexchangepb.DeleteDataExchangeRequest{
                Name: fmt.Sprintf("projects/%s/locations/%s/dataExchanges/%s", projectID, location, exchangeID),
        }
        return client.DeleteDataExchange(ctx, req)
}

 
/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The parent resource path of the DataExchanges.
 *  e.g. `projects/myproject/locations/US`.
 */
// const parent = 'abc123'
/**
 *  The maximum number of results to return in a single response page. Leverage
 *  the page tokens to iterate through the entire collection.
 */
// const pageSize = 1234
/**
 *  Page token, returned by a previous call, to request the next page of
 *  results.
 */
// const pageToken = 'abc123'

// Imports the Dataexchange library
const {AnalyticsHubServiceClient} =
  require('@google-cloud/bigquery-data-exchange').v1beta1;

// Instantiates a client
const dataexchangeClient = new AnalyticsHubServiceClient();

async function callListDataExchanges() {
  // Construct request
  const request = {
    parent,
  };

  // Run request
  const iterable = await dataexchangeClient.listDataExchangesAsync(request);
  for await (const response of iterable) {
    console.log(response);
  }
}

callListDataExchanges();

Risorse aggiuntive

C#GoJavaNode.jsPHPPythonRuby

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per C#:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per Go:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per Java:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per Node.js:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per PHP:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per Python:

Il seguente elenco contiene link ad altre risorse correlate alla libreria client per Ruby:

Che cosa succede dopo?

Per ulteriori informazioni, consulta Introduzione ad Analytics Hub.