Voraussetzungen für die Indexing API

Damit du die Indexing API verwenden kannst, musst du ggf. noch einige Schritte ausführen:

Projekt für den Client erstellen

Bevor Sie Anfragen an die Indexing API senden können, müssen Sie Google über Ihren Client informieren und den Zugriff auf die API aktivieren. Verwenden Sie dazu die Google API Console, um ein Projekt zu erstellen und um Ihre Anwendung zu registrieren. Bei einem Projekt handelt es sich um eine mit einem Namen versehene Sammlung von Einstellungen und Informationen zum API-Zugriff.

Damit du die Indexing API verwenden kannst, musst du zuerst mithilfe des Einrichtungstools ein Projekt in der Google API Console erstellen. Damit wird die API aktiviert und es werden Anmeldedaten erzeugt.

Dienstkonto erstellen

  1. Öffne die Seite Dienstkonten. Wähle ein Projekt aus, wenn du dazu aufgefordert wirst.
  2. Klicke auf add Dienstkonto erstellen und gib einen Namen und eine Beschreibung für das Dienstkonto ein. Du kannst die standardmäßige Dienstkonto-ID verwenden oder eine andere eindeutige ID auswählen. Wenn du fertig bist, kannst du auf Erstellen klicken.
  3. Für den folgenden Abschnitt Dienstkontoberechtigungen (optional) sind keine Maßnahmen erforderlich. Klicke auf Weiter.
  4. Scrolle auf dem Bildschirm Nutzern Zugriff auf dieses Dienstkonto erteilen nach unten zum Abschnitt Schlüssel erstellen. Klicke auf add Schlüssel erstellen.
  5. Wähle in der angezeigten Seitenleiste das Format für deinen Schlüssel aus. Empfohlen wird JSON.
  6. Klicke auf Erstellen. Dein neues öffentliches/privates Schlüsselpaar wird generiert und auf deinen Computer heruntergeladen. Dies ist die einzige Kopie dieses Schlüssels. Informationen, wie du den Schlüssel sicher speicherst, findest du unter Dienstkontoschlüssel verwalten.
  7. Klicke im Dialogfeld Privater Schlüssel auf Ihrem Computer gespeichert auf Schließen und dann auf Fertig, um zur Tabelle deiner Dienstkonten zurückzukehren.

Die folgenden Schritte sind nur erforderlich, wenn du der G Suite domainweite Berechtigungen für das Dienstkonto erteilst.

  1. Suche das neu erstellte Dienstkonto in der Tabelle. Klicke unter Aktionen auf more_vert und dann auf Bearbeiten.
  2. Klicke in den Dienstkontodetails auf expand_more Domainweite Delegation einblenden und prüfe, ob das Kästchen Domainweite G Suite-Delegation aktivieren angeklickt ist.
  3. Wenn du den OAuth-Zustimmungsbildschirm der App noch nicht konfiguriert hast, musst du dies tun, bevor du die domainweite Delegation aktivieren kannst. Konfiguriere den OAuth-Zustimmungsbildschirm nach der Anleitung auf dem Bildschirm. Wiederhole dann die Schritte oben und klicke das Kästchen noch einmal an.
  4. Klicke auf Speichern, um das Dienstkonto zu aktualisieren und zur Tabelle der Dienstkonten zurückzukehren. Die neue Spalte Domainweite Delegation wird angezeigt. Klicke auf Client-ID ansehen, um die Client-ID abzurufen und zu notieren.

Inhaberschaft der Website in der Search Console bestätigen

In diesem Schritt bestätigen Sie, dass Sie die Kontrolle über Ihre Web-Property haben.

So bestätigen Sie die Inhaberschaft Ihrer Website:

  1. Führen Sie die empfohlenen Schritte zur Bestätigung der Inhaberschaft Ihrer Web-Property aus.
  2. Öffnen Sie nach der Bestätigung Ihrer Web-Property die Search Console.
  3. Klicke auf deine bestätigte Property.
  4. Wähle im Einstellungsbereich neben deiner bestätigten Property die Option Überprüfungsdetails aus.
  5. Klicke unter Bestätigte Inhaber auf Inhaber hinzufügen.
  6. Füge der Property die E-Mail-Adresse deines Dienstkontos als Inhaber hinzu. Du kannst die E-Mail-Adresse deines Dienstkontos an zwei Stellen finden:
    • Im Feld client_email im privaten JSON-Schlüssel, den du beim Erstellen deines Projekts heruntergeladen hast.
    • In der Spalte Dienstkonto-ID der Ansicht "Dienstkonten" in der Developers Console

    Die E-Mail-Adresse hat ungefähr folgendes Format:

    my-service-account@project-name.google.com.iam.gserviceaccount.com

    Beispiel: "my-service-account@test-project-42.google.com.iam.gserviceaccount.com".

Zugriffstoken anfordern

Der Aufruf der Indexing API muss mit einem OAuth-Token authentifiziert werden. Diesen erhältst du im Austausch gegen deinen privaten Schlüssel. Google bietet API-Clientbibliotheken an, über die OAuth-Token für unterschiedliche Sprachen angefordert werden können.

Anforderungen

Anfragen an die Indexing API müssen folgende Voraussetzungen erfüllen:

  1. https://www.googleapis.com/auth/indexing wird als Bereich verwendet.
  2. Einer der unter API verwenden beschriebenen Endpunkte muss verwendet werden.
  3. Das Dienstkonto-Zugriffstoken muss enthalten sein.
  4. Der Text der Anfrage muss wie in API verwenden beschrieben definiert sein.

Beispiele

In den folgenden Beispielen wird erläutert, wie Sie ein OAuth-Zugriffstoken erhalten:

Python

Ruft ein OAuth-Token mithilfe der Google API-Clientbibliothek für Python ab:

from oauth2client.service_account import ServiceAccountCredentials
    import httplib2

    SCOPES = [ "https://www.googleapis.com/auth/indexing" ]
    ENDPOINT = "https://indexing.googleapis.com/v3/urlNotifications:publish"

    # service_account_file.json is the private key that you created for your service account.
    JSON_KEY_FILE = "service_account_file.json"

    credentials = ServiceAccountCredentials.from_json_keyfile_name(JSON_KEY_FILE, scopes=SCOPES)

    http = credentials.authorize(httplib2.Http())

    # Define contents here as a JSON string.
    # This example shows a simple update request.
    # Other types of requests are described in the next step.

    content = """{
      \"url\": \"http://example.com/jobs/42\",
      \"type\": \"URL_UPDATED\"
    }"""

    response, content = http.request(ENDPOINT, method="POST", body=content)

    

Java

Ruft ein OAuth-Token mithilfe der API-Clientbibliothek für Java ab:

String scopes = "https://www.googleapis.com/auth/indexing";
    String endPoint = "https://indexing.googleapis.com/v3/urlNotifications:publish";

    JsonFactory jsonFactory = new JacksonFactory();

    // service_account_file.json is the private key that you created for your service account.
    InputStream in = IOUtils.toInputStream("service_account_file.json");

    GoogleCredential credentials =
      GoogleCredential.fromStream(in, this.httpTransport, jsonFactory).createScoped(Collections.singleton(scopes));

    GenericUrl genericUrl = new GenericUrl(endPoint);
    HttpRequestFactory requestFactory = this.httpTransport.createRequestFactory();

    // Define content here. The structure of the content is described in the next step.
    String content = "{"
      + "\"url\": \"http://example.com/jobs/42\","
      + "\"type\": \"URL_UPDATED\","
      + "}";

    HttpRequest request =
      requestFactory.buildPostRequest(genericUrl, ByteArrayContent.fromString("application/json", content));

    credentials.initialize(request);
    HttpResponse response = request.execute();
    int statusCode = response.getStatusCode();
    

PHP

Ruft ein OAuth-Token mithilfe der API-Clientbibliothek für PHP ab:

require_once 'google-api-php-client/vendor/autoload.php';

    $client = new Google_Client();

    // service_account_file.json is the private key that you created for your service account.
    $client->setAuthConfig('service_account_file.json');
    $client->addScope('https://www.googleapis.com/auth/indexing');

    // Get a Guzzle HTTP Client
    $httpClient = $client->authorize();
    $endpoint = 'https://indexing.googleapis.com/v3/urlNotifications:publish';

    // Define contents here. The structure of the content is described in the next step.
    $content = '{
      "url": "http://example.com/jobs/42",
      "type": "URL_UPDATED"
    }';

    $response = $httpClient->post($endpoint, [ 'body' => $content ]);
    $status_code = $response->getStatusCode();
    

Node.js

Ruft ein OAuth-Token mithilfe der Node.js-Clientbibliothek ab:

var request = require("request");
    var google = require("googleapis");
    var key = require("./service_account.json");

    const jwtClient = new google.auth.JWT(
      key.client_email,
      null,
      key.private_key,
      ["https://www.googleapis.com/auth/indexing"],
      null
    );

    jwtClient.authorize(function(err, tokens) {
      if (err) {
        console.log(err);
        return;
      }
      let options = {
        url: "https://indexing.googleapis.com/v3/urlNotifications:publish",
        method: "POST",
        // Your options, which must include the Content-Type and auth headers
        headers: {
          "Content-Type": "application/json"
        },
        auth: { "bearer": tokens.access_token },
        // Define contents here. The structure of the content is described in the next step.
        json: {
          "url": "http://example.com/jobs/42",
          "type": "URL_UPDATED"
        }
      };
      request(options, function (error, response, body) {
        // Handle the response
        console.log(body);
      });
    });
    

Diese Beispiele zeigen nicht nur, wie du ein Token erhältst, sondern auch, wo du den Hauptteil der Anfragenachricht einfügen kannst. Informationen zu den möglichen Arten von Aufrufen und zur Struktur der Nachrichtentexte für diese Aufrufe findest du unter API verwenden.