Trasmetti report in streaming utilizzando GoogleAdsService

Per recuperare le entità dell'API Google Ads e i dati dei report, utilizza uno dei seguenti metodi:

• GoogleAdsService.SearchStream
• GoogleAdsService.Search

Ecco le distinzioni di alto livello per i due metodi:

	GoogleAdsService.SearchStream	GoogleAdsService.Search
Adatto per il codice di produzione	Sì	Sì
Servizio	GoogleAdsService	GoogleAdsService
Scenario	Recupero di oggetti e report	Recupero di oggetti e report
Risposta	Stream di oggetti GoogleAdsRow	Pagine di GoogleAdsRow oggetti
Campi della risposta	Solo quelli specificati nella query	Solo quelli specificati nella query
Limiti giornalieri	Limiti giornalieri basati sui livelli di accesso	Limiti giornalieri basati sui livelli di accesso

SearchStream contro Search

Mentre Search invia più richieste paginate per scaricare un intero report, SearchStream invia una singola richiesta e avvia una connessione gRPC persistente con l'API Google Ads indipendentemente dalle dimensioni del report.

Per SearchStream, i pacchetti di dati iniziano a essere scaricati immediatamente in batch di SearchGoogleAdsStreamResponse oggetti. Il codice può eseguire l'iterazione sui batch in entrata man mano che arrivano senza attendere il completamento dell'intero stream.

Eliminando il tempo di andata e ritorno della rete necessario per richiedere ogni singola pagina di una risposta Search, SearchStream offre prestazioni migliori rispetto alla paginazione, soprattutto per i report di grandi dimensioni.

Esempio

Questo esempio esamina un report composto da 100,000 righe. La tabella seguente suddivide le differenze tra richiesta e risposta tra i due metodi:

	SearchStream	Search
Dimensioni pagina	Non applicabile	10.000 righe per pagina
Numero di richieste API	1 richiesta	10 richieste
Numero di risposte dell'API	1 stream continuo	10 risposte

Fattori di rendimento

Per la maggior parte dei casi d'uso, consigliamo SearchStream rispetto a Search per i seguenti motivi:

• Report di una singola pagina (meno di 10.000 righe): non ci sono differenze di prestazioni significative tra i due metodi.
• Report di più pagine: SearchStream è in genere più veloce perché vengono evitati più andata e ritorno di rete e la lettura o la scrittura dalla cache del disco è meno importante.
• Efficienza della memoria: quando elabori report di grandi dimensioni con SearchStream, esegui l'iterazione sui blocchi di stream ed elabora le righe man mano che arrivano anziché memorizzare tutte le righe nella memoria contemporaneamente per evitare errori di esaurimento della memoria (OOM).
• Resilienza della connessione: poiché SearchStream si basa su una connessione persistente, gli stream a lunga esecuzione possono essere interrotti da interruzioni di rete o timeout di scadenza. Configura i timeout RPC appropriati e implementa la logica di ripetizione per gli errori di stream temporanei.

Limiti di frequenza

I limiti operativi giornalieri per entrambi i metodi rispettano i limiti standard e i livelli di accesso del tuo progetto Google Cloud. Una singola query di report logica viene conteggiata come un'operazione ai fini della quota operativa giornaliera indipendentemente dal fatto che il risultato venga trasmesso in streaming con SearchStream o recuperato su più pagine memorizzate nella cache utilizzando Search con un page_token. Tuttavia, ogni richiesta Search paginata viene comunque conteggiata come una singola chiamata RPC rispetto ai limiti di frequenza a breve termine.

Codice di esempio

Il seguente esempio di codice mostra come eseguire una query di report di streaming utilizzando le librerie client:

Java

private void runExample(GoogleAdsClient googleAdsClient, long customerId) {
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    String query = "SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id";
    // Constructs the SearchGoogleAdsStreamRequest.
    SearchGoogleAdsStreamRequest request =
        SearchGoogleAdsStreamRequest.newBuilder()
            .setCustomerId(Long.toString(customerId))
            .setQuery(query)
            .build();

    // Creates and issues a search Google Ads stream request that will retrieve all campaigns.
    ServerStream<SearchGoogleAdsStreamResponse> stream =
        googleAdsServiceClient.searchStreamCallable().call(request);

    // Iterates through and prints all of the results in the stream response.
    for (SearchGoogleAdsStreamResponse response : stream) {
      for (GoogleAdsRow googleAdsRow : response.getResultsList()) {
        System.out.printf(
            "Campaign with ID %d and name '%s' was found.%n",
            googleAdsRow.getCampaign().getId(), googleAdsRow.getCampaign().getName());
      }
    }
  }
}
GetCampaigns.java
      

C#

public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsService = client.GetService(
        Services.V25.GoogleAdsService);

    // Create a query that will retrieve all campaigns.
    string query = @"SELECT
                    campaign.id,
                    campaign.name,
                    campaign.network_settings.target_content_network
                FROM campaign
                ORDER BY campaign.id";

    try
    {
        // Issue a search request.
        googleAdsService.SearchStream(customerId.ToString(), query,
            delegate (SearchGoogleAdsStreamResponse resp)
            {
                foreach (GoogleAdsRow googleAdsRow in resp.Results)
                {
                    Console.WriteLine("Campaign with ID {0} and name '{1}' was found.",
                        googleAdsRow.Campaign.Id, googleAdsRow.Campaign.Name);
                }
            }
        );
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}
GetCampaigns.cs
      

PHP

public static function runExample(GoogleAdsClient $googleAdsClient, int $customerId)
{
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves all campaigns.
    $query = 'SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id';
    // Issues a search stream request.
    /** @var GoogleAdsServerStreamDecorator $stream */
    $stream = $googleAdsServiceClient->searchStream(
        SearchGoogleAdsStreamRequest::build($customerId, $query)
    );

    // Iterates over all rows in all messages and prints the requested field values for
    // the campaign in each row.
    foreach ($stream->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        printf(
            "Campaign with ID %d and name '%s' was found.%s",
            $googleAdsRow->getCampaign()->getId(),
            $googleAdsRow->getCampaign()->getName(),
            PHP_EOL
        );
    }
}
GetCampaigns.php
      

Python

def main(client: GoogleAdsClient, customer_id: str) -> None:
    ga_service: GoogleAdsServiceClient = client.get_service("GoogleAdsService")

    query: str = """
        SELECT
          campaign.id,
          campaign.name
        FROM campaign
        ORDER BY campaign.id"""

    # Issues a search request using streaming.
    stream: Iterator[SearchGoogleAdsStreamResponse] = ga_service.search_stream(
        customer_id=customer_id, query=query
    )

    for batch in stream:
        rows: List[GoogleAdsRow] = batch.results
        for row in rows:
            print(
                f"Campaign with ID {row.campaign.id} and name "
                f'"{row.campaign.name}" was found.'
            )
get_campaigns.py
      

Ruby

def get_campaigns(customer_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  responses = client.service.google_ads.search_stream(
    customer_id: customer_id,
    query: 'SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id',
  )

  responses.each do |response|
    response.results.each do |row|
      puts "Campaign with ID #{row.campaign.id} and name '#{row.campaign.name}' was found."
    end
  end
end
get_campaigns.rb
      

Perl

sub get_campaigns {
  my ($api_client, $customer_id) = @_;

  # Create a search Google Ads stream request that will retrieve all campaigns.
  my $search_stream_request =
    Google::Ads::GoogleAds::V25::Services::GoogleAdsService::SearchGoogleAdsStreamRequest
    ->new({
      customerId => $customer_id,
      query      =>
        "SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id"
    });

  # Get the GoogleAdsService.
  my $google_ads_service = $api_client->GoogleAdsService();

  my $search_stream_handler =
    Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
      service => $google_ads_service,
      request => $search_stream_request
    });

  # Issue a search request and process the stream response to print the requested
  # field values for the campaign in each row.
  $search_stream_handler->process_contents(
    sub {
      my $google_ads_row = shift;
      printf "Campaign with ID %d and name '%s' was found.\n",
        $google_ads_row->{campaign}{id}, $google_ads_row->{campaign}{name};
    });

  return 1;
}
get_campaigns.pl
      

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche del metodo. Dovrai creare il payload JSON in base alle definizioni proto.

Risorse chiave:

• Utilizzo di REST
• Struttura dell'interfaccia REST
• Mappature dei campi JSON
• Consulta il Riferimento API REST per il servizio e il metodo specifici.