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 Anfragen an die Indexing API gesendet werden können, musst du Google über deinen Client informieren und den Zugriff auf die API aktivieren. Verwende dazu die Google API Console, um ein Projekt zu erstellen und um deine 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. Dadurch wird die API aktiviert und Anmeldedaten erzeugt.

Dienstkonto erstellen

  1. Öffne die Seite Dienstkonten. Wähle ein Projekt aus, wenn du dazu aufgefordert wirst.
  2. Klicke auf 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, klicke auf Erstellen.
  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 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 dazu, wie du den Schlüssel sicher speicherst, findest du unter Dienstkontoschlüssel verwalten.
  7. Klicke im Dialogfeld Privater Schlüssel auf deinem Computer gespeichert auf Schließen und dann auf Fertig, um zur Tabelle deiner Dienstkonten zurückzukehren.

Dienstkonto als Websiteinhaber hinzufügen

So fügst du dein Dienstkonto als Websiteinhaber hinzu:

  1. Bestätige zuerst in der Search Console, dass du der Inhaber der Website bist, und
  2. füge dann dein Dienstkonto als Inhaber hinzu.

1. Bestätigen, dass du der Inhaber der Website bist

In der Search Console kannst du die Inhaberschaft der Website bestätigen. Dort werden verschiedene Bestätigungsmethoden unterstützt. Du kannst entweder eine Domain-Property (beispiel.de) oder eine URL-Präfix-Property (https://beispiel.de oder https://beispiel.de/ein/pfad/) erstellen, um deine Website anzugeben. Hinweis: Websites werden in der Search Console als Properties bezeichnet.

2. Deinem Dienstkonto Inhaberstatus geben

Füge dein Dienstkonto als Nächstes als (delegierten) Websiteinhaber hinzu:

  1. Öffne die Webmaster-Zentrale.
  2. Klicke auf die Property, für die du die Inhaberschaft bestätigt hast.
  3. Klicke in der Liste Bestätigter Inhaber auf Inhaber hinzufügen.
  4. Gib die E-Mail-Adresse deines Dienstkontos als delegierten Inhaber an. 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 folgendes Format:
    my-service-account@project-name.google.com.iam.gserviceaccount.com
    Beispiel: mein-dienstkonto@testprojekt-42.google.de.ichbin.gdienstkonto.de

Zugriffstoken anfordern

Jeder Aufruf an die Indexing API muss mit einem OAuth-Token authentifiziert werden. Diesen erhältst du im Austausch gegen deinen privaten Schlüssel. Jedes Token ist eine bestimmte Zeit lang gültig. Google bietet API-Clientbibliotheken an, über die OAuth-Tokens für unterschiedliche Sprachen angefordert werden können.

Voraussetzungen

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. Der Dienstkonto-Zugriffstoken muss enthalten sein.
  4. Der Hauptteil der Anfrage muss wie in API verwenden beschrieben definiert sein.

Beispiele

In den folgenden Beispielen wird erläutert, wie du ein OAuth-Zugriffstoken erhältst:

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 erhalten, sondern auch, wo du den Hauptteil der Anfragenachricht hinzufügen kannst. Informationen zu den möglichen Arten von Aufrufen und zur Struktur der Nachrichtentexte für diese Aufrufe findest du unter API verwenden.