Codelab: Domainbestätigung für Google Workspace automatisieren

Warum sollte ich 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 die Dienste zu aktivieren.

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

Wenn ein neu erstellter Kunde zum ersten Mal auf die Admin-Konsole (unter admin.google.com) zugreift, wird er durch einen geführten Prozess geführt.

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. Für diese Schritte sind in der Regel technische Kenntnisse des Kunden erforderlich, der die Domain weiterverkauft hat.

In diesem Codelab wird erläutert, wie Sie diese Automatisierung mit der Site Verification API implementieren.

Hinweise

Für dieses Codelab müssen Sie außerdem das Codelab zur End-to-End-Bereitstellung von Workspace abgeschlossen haben.

Übersicht

Die Bestätigung der Domain für die Google Workspace-Berechtigung umfasst mehrere API-Aufrufe.

Schritte zur Automatisierung der Domainbestätigung

Die Website Verification API ist nicht speziell für Reseller gedacht. Die Domainbestätigung ist ein Signal, das in verschiedenen Google-Produkten (z. B. Search Console und Google Ads) verwendet wird. Bei diesem Verfahren wird der Super Admin Ihrer Resellerdomain als Inhaber der Domain und der erste Administrator Ihres Kunden als Mitinhaber festgelegt. Weitere Informationen zu diesen Konzepten finden Sie auf der Seite Einstieg in die Site Verification API.

Schritt 1: Vorbereitung auf die Websitebestätigungs-API

Schritt 2: Bestätigungstoken abrufen

In diesem Codelab liegt der Schwerpunkt auf der gängigsten Methode zur Bestätigung einer Domain: mithilfe von TXTDNS-Einträgen. Die API für die Websitebestätigung unterstützt andere Bestätigungsmethoden.

Um das Token abzurufen, das Sie als TXT-Eintrag platzieren, müssen Sie Tokens für type=INET_DOMAIN und verificationMethod=DNS_TXT abrufen.

Ersetzen Sie im folgenden Code diese 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 für eine Resellerdomain.

  • customerDomain: Die Domain des Endkunden. Wenn Sie dieses Codelab in Ihrer Test-Partner-Sales Console ausführen, achten Sie darauf, dass die Domain den Domain-Benennungskonventionen entspricht.

C#

Mit den folgenden Importen:

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

Mit den folgenden Importen:

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

Mit den folgenden Importen:

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

Mit dem 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

Mit den folgenden Importen:

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

Schreibe den Code, um das Token als TXT-Eintrag in die DNS-Einträge der Kundendomain einzufügen.

Bei neuen Domains ist jetzt der richtige Zeitpunkt, die für Gmail erforderlichen MX-Einträge einzurichten.

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. Rufen Sie dazu webResource.insert() auf.

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

Wenn der Aufruf keine Fehler zurückgibt, betrachtet die Websiteüberprüfungs-API die Domain als bestätigt und alle E-Mail-Adressen im Feld owners der webResource als bestätigten Inhaber.

Es kann etwa drei Stunden dauern, bis der Überprüfungsstatus im Google Workspace-Konto Ihres Kunden übernommen wird. Du kannst die sofortige Weiterleitung des Status erzwingen, indem du den Administrator des Kunden (der beim Aufruf von provisionCloudIdentity erstellt wurde) als owner der webResource festlegst.

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")