Codelab: Domainbestätigung für Google Workspace automatisieren

Warum die Domainbestätigung automatisieren?

Mit der Cloud Channel API können Sie Google Workspace-Berechtigungen in großem Umfang bereitstellen. Der Kunde muss jedoch die folgenden Schritte ausführen, um Dienste zu aktivieren.

  1. Nutzungsbedingungen akzeptieren
  2. Inhaberschaft der Domain bestätigen
  3. MX-Einträge einrichten

Ein neu erstellter Kunde durchläuft einen geführten Prozess mit Anforderungen, wenn er zum ersten Mal auf die Admin-Konsole (unter admin.google.com) zugreift.

Wenn Sie programmatischen Zugriff auf die DNS-Einträge der Domain haben (z. B. wenn Sie die Domain an den Kunden weiterverkauft haben), können Sie die Schritte 2 und 3 automatisieren, um die Aktivierungsraten zu erhöhen. Diese Schritte erfordern in der Regel technisches Wissen vom weiterverkauften Kunden.

In diesem Codelab wird erläutert, wie Sie die Site Verification API verwenden, um diese Automatisierung zu implementieren.

Hinweis

  • Führen Sie das Codelab zur API-Einrichtung aus, um ein Google Cloud Projekt einzurichten und ein Dienstkonto zu erstellen, mit dem die Cloud Channel API aufgerufen werden kann.

  • Informationen zu den Channel Services-Vorgängen.

  • Wir empfehlen, für dieses Codelab Ihre Test Partner Sales Console zu verwenden.

Außerdem wird davon ausgegangen, dass Sie das Codelab zur End-to-End-Bereitstellung von Workspace abgeschlossen haben.

Übersicht

Für die Bestätigung der Domain für die Google Workspace-Berechtigung sind mehrere API-Aufrufe erforderlich.

Schritte zum Automatisieren der Domainbestätigung

Die Site Verification API ist nicht speziell für Reseller. Die Domainbestätigung ist ein Signal, das in verschiedenen Google-Produkten verwendet wird (Search Console, Google Ads usw.). Der hier beschriebene Prozess basiert darauf, den Super-Admin Ihrer Reseller-Domain als „Inhaber“ der Domain festzulegen und den ersten Admin Ihres Kunden als Mitinhaber festzulegen. Weitere Informationen zu diesen Konzepten finden Sie auf der Seite Erste Schritte mit der Site Verification API.

Schritt 1: Site Verification API vorbereiten

Schritt 2: Bestätigungstoken abrufen

In diesem Codelab wird die häufigste Methode zum Bestätigen einer Domain behandelt: die Verwendung von TXT-DNS-Einträgen. Die Site Verification API unterstützt auch andere Bestätigungsmethoden.

Um das Token abzurufen, das Sie als TXT Eintrag platzieren, benötigen Sie Token für type=INET_DOMAIN und verificationMethod=DNS_TXT.

Ersetzen Sie im folgenden Code die Variablen durch Ihre Informationen.

  • jsonKeyFile: Der Pfad zur JSON-Schlüsseldatei, die beim Erstellen eines Dienstkontos generiert wurde .
  • resellerAdminUser: Die E-Mail-Adresse eines Super-Admins der Reseller-Domain.

  • customerDomain: Die Domain des Endkunden. Wenn Sie dieses Codelab in Ihrer Test Partner Sales Console ausführen, müssen die Domain-Benennungskonventionen eingehalten werden.

C#

Verwenden Sie die folgenden Importe:

using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.SiteVerification.v1;
using Google.Apis.SiteVerification.v1.Data;

Erstellen Sie den API-Client und rufen Sie das Token ab:

// Set up credentials with user impersonation
ICredential credential = GoogleCredential.FromFile(jsonKeyFile)
                             .CreateScoped("https://www.googleapis.com/auth/siteverification")
                             .CreateWithUser(resellerAdminUser);

// Create the API service
var verificationService = new SiteVerificationService(new BaseClientService.Initializer{
    HttpClientInitializer = credential,
});

// Fetch the token
var request = new SiteVerificationWebResourceGettokenRequest {
  VerificationMethod = "DNS_TXT",
  Site = new SiteVerificationWebResourceGettokenRequest.SiteData {
    Type = "INET_DOMAIN",
    Identifier = customerDomain
  }
};
var response = verificationService.WebResource.GetToken(request).Execute();
string token = response.Token;
Console.WriteLine("Site Verification token: " + token);

Go

Verwenden Sie die folgenden Importe:

import (
  "context"
  "fmt"
  "os"

  "golang.org/x/oauth2/google"
  "google.golang.org/api/option"
  "google.golang.org/api/siteverification/v1"
)

Erstellen Sie den API-Client und rufen Sie das Token ab:

ctx := context.Background()

// Set up credentials with user impersonation
jsonKey, _ := os.ReadFile(jsonKeyFile)
jwt, _ := google.JWTConfigFromJSON(jsonKey, "https://www.googleapis.com/auth/siteverification")
jwt.Subject = resellerAdminUser
tokenSource := jwt.TokenSource(ctx)

// Create the API Service
verificationService, _ := siteverification.NewService(ctx, option.WithTokenSource(tokenSource))

// Fetch the token
req := &siteverification.SiteVerificationWebResourceGettokenRequest{
  Site: &siteverification.SiteVerificationWebResourceGettokenRequestSite{
    Type:       "INET_DOMAIN",
    Identifier: customerDomain,
  },
  VerificationMethod: "DNS_TXT",
}
res, _ := verificationService.WebResource.GetToken(req).Do()
token := res.Token
fmt.Println("Site verification token: " + token)

Java

Verwenden Sie die folgenden Importe:

import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ServiceAccountCredentials;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.siteVerification.SiteVerification;
import com.google.api.services.siteVerification.SiteVerificationScopes;
import com.google.api.services.siteVerification.model.SiteVerificationWebResourceGettokenRequest;
import com.google.api.services.siteVerification.model.SiteVerificationWebResourceGettokenResponse;
import com.google.api.services.siteVerification.model.SiteVerificationWebResourceResource;
import java.io.FileInputStream;
import java.util.Arrays;

Erstellen Sie den API-Client und rufen Sie das Token ab:

// Set up credentials with user impersonation
FileInputStream jsonKeyFileSteam = new FileInputStream(JSON_KEY_FILE);
GoogleCredentials credentials = ServiceAccountCredentials.fromStream(jsonKeyFileSteam)
                                    .createScoped("https://www.googleapis.com/auth/siteverification")
                                    .createDelegated(RESELLER_ADMIN_USER);

// Create the API service
SiteVerification verificationService = new SiteVerification.Builder(
    GoogleNetHttpTransport.newTrustedTransport(),
    JacksonFactory.getDefaultInstance(),
    new HttpCredentialsAdapter(credentials)).build();

// Fetch the token
SiteVerificationWebResourceGettokenRequest request =
    new SiteVerificationWebResourceGettokenRequest()
        .setVerificationMethod("DNS_TXT")
        .setSite(new SiteVerificationWebResourceGettokenRequest.Site()
            .setType("INET_DOMAIN")
            .setIdentifier(CUSTOMER_DOMAIN));
SiteVerificationWebResourceGettokenResponse response =
    verificationService.webResource().getToken(request).execute();
String token = response.getToken();
System.out.println("Site Verification token: " + token);

Node.js

Verwenden Sie den folgenden Import:

const {google} = require('googleapis');

Erstellen Sie den API-Client und rufen Sie das Token ab:

// Set up credentials with user impersonation
const authJWT = new JWT({
  keyFile: jsonKeyFile,
  scopes: ['https://www.googleapis.com/auth/siteverification'],
  subject: resellerAdminUser,
});

// Create the API service
const verificationService = google.siteVerification({version: 'v1', auth: authJWT});

// Fetch the token
const { data } = await verificationService.webResource.getToken({
  requestBody: {
    site: {
      type: 'INET_DOMAIN',
      identifier: customerDomain,
    },
    verificationMethod: 'DNS_TXT',
  }
});
const token = data.token;
console.log(`Site Verification token: ${token}`);

PHP

Erstellen Sie den API-Client und rufen Sie das Token ab:

// Set up credentials with user impersonation
$client = new Google_Client();
$client->setAuthConfig($JSON_KEY_FILE);
$client->setSubject($RESELLER_ADMIN_USER);
$client->setScopes('https://www.googleapis.com/auth/siteverification');

// Create the API service
$verificationService = new Google_Service_SiteVerification($client);

// Fetch the token
$request = new Google_Service_SiteVerification_SiteVerificationWebResourceGettokenRequest([
  'verificationMethod' => 'DNS_TXT',
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN
  ]
]);
$response = $verificationService->webResource->getToken($request);
$token = $response->token;
print 'Site Verification token: ' . $token . PHP_EOL;

Python

Verwenden Sie die folgenden Importe:

from google.oauth2 import service_account
from apiclient.discovery import build

Erstellen Sie den API-Client und rufen Sie das Token ab:

# Set up credentials with user impersonation
credentials = service_account.Credentials.from_service_account_file(
    JSON_KEY_FILE, scopes=["https://www.googleapis.com/auth/siteverification"])
credentials_delegated = credentials.with_subject(RESELLER_ADMIN_USER)

# Create the API service
verification_service = build(serviceName="siteVerification", version="v1",
    credentials=credentials_delegated)

# Fetch the token
response = verification_service.webResource().getToken(
  body={
    "site": {
      "type": "INET_DOMAIN",
      "identifier": CUSTOMER_DOMAIN
    },
    "verificationMethod": "DNS_TXT"
  }).execute()
token = response["token"]
print("Site Verification token: " + token)

Schritt 3: Bestätigungstoken platzieren

Schreiben Sie den Code, um das Token als TXT-Eintrag zu den DNS-Einträgen der Kundendomain hinzuzufügen.

Bei neuen Domains ist jetzt ein guter Zeitpunkt, um die MX Einträge einzurichten, die für Gmail erforderlich sind.

Schritt 4: Domainbestätigung auslösen

Sobald das Token als TXT-Eintrag platziert wurde, können Sie die Site Verification API aufrufen, um die Bestätigung auszulösen. Dazu rufen Sie auf webResource.insert().

Wenn das erwartete Token nicht gefunden wird, schlägt der Aufruf mit einem 400-Fehler fehl. Sie können eine exponentielle Backoff-Wiederholungsstrategie implementieren, bis der Aufruf erfolgreich ist, um Verzögerungen bei der DNS-Weitergabe auszugleichen.

Wenn der Aufruf ohne Fehler zurückgegeben wird, gilt die Domain für die Site Verification API als bestätigt und alle E-Mail-Adressen im Feld owners von webResource sind bestätigte Inhaber.

Es kann etwa 3 Stunden dauern, bis der Bestätigungsstatus an das Google Workspace-Konto Ihres Kunden weitergegeben wird. Sie können die Weitergabe des Status sofort erzwingen, indem Sie den Admin des Kunden (der beim Aufruf von provisionCloudIdentity) erstellt wurde) als owner von webResource festlegen.

C# 

// Set the customer's admin user as an owner to make sure the domain
// verification status is instantly propagated to the Workspace account
string[] owners = { "admin@" + customerDomain };

var resource = new SiteVerificationWebResourceResource {
  Site = new SiteVerificationWebResourceResource.SiteData {
    Type = "INET_DOMAIN",
    Identifier = customerDomain
  },
  Owners = owners
};

resource = verificationService.WebResource.Insert(resource, "DNS_TXT").Execute();
Console.WriteLine("=== Domain has been verified");

Go 

// Set the customer's admin user as an owner to make sure the domain
// verification status is instantly propagated to the Workspace account
resource := &siteverification.SiteVerificationWebResourceResource{
  Site: &siteverification.SiteVerificationWebResourceResourceSite{
    Type:       "INET_DOMAIN",
    Identifier: customerDomain,
  },
  Owners: []string{"admin@" + customerDomain},
}
resource, err := verificationService.WebResource.Insert("DNS_TXT", resource).Do()
if err != nil {
  fmt.Println(err)
} else {
  fmt.Println("=== Domain has been verified")
}

Java 

// Set the customer's admin user as an owner to make sure the domain
// verification status is instantly propagated to the Workspace account
SiteVerificationWebResourceResource resource =
    new SiteVerificationWebResourceResource()
        .setSite(new SiteVerificationWebResourceResource.Site()
            .setIdentifier(CUSTOMER_DOMAIN)
            .setType("INET_DOMAIN"))
        .setOwners(Arrays.asList("admin@" + CUSTOMER_DOMAIN));

resource = verificationService.webResource().insert("DNS_TXT", resource).execute();
System.out.println("=== Domain has been verified");

Node.js 

// Set the customer's admin user as an owner to make sure the domain
// verification status is instantly propagated to the Workspace account
await verificationService.webResource.insert({
  verificationMethod: 'DNS_TXT',
  requestBody: {
    site: {
      type: 'INET_DOMAIN',
      identifier: customerDomain,
    },
    owners: [`admin@${customerDomain}`],
  }
});
console.log('=== Domain has been verified');

PHP 

// Set the customer's admin user as an owner to make sure the domain
// verification status is instantly propagated to the Workspace account
$resource = new Google_Service_SiteVerification_SiteVerificationWebResourceResource([
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN,
  ],
  'owners' => ['admin@' . $CUSTOMER_DOMAIN]
]);

$resource = $verificationService->webResource->insert('DNS_TXT', $resource);
print '=== Domain has been verified' . PHP_EOL;

Python 

# Set the customer's admin user as an owner to make sure the domain
# verification status is instantly propagated to the Workspace account
resource = verification_service.webResource().insert(
  verificationMethod="DNS_TXT",
  body={
    "site": {
      "type": "INET_DOMAIN",
      "identifier": CUSTOMER_DOMAIN
    },
    "owners": ["admin@" + CUSTOMER_DOMAIN]
  }).execute()
print("=== Domain has been verified")