Codelab: Domainbestätigung für Google Workspace automatisieren

Vorteile der automatischen Domainbestätigung

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

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

Neu erstellte Kunden müssen einen geführten Anforderungsprozess durchlaufen, wenn sie zum ersten Mal auf die Admin-Konsole (auf admin.google.com) zugreifen.

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, da diese Schritte normalerweise technisches Wissen eines Reseller-Kunden erfordern.

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

Hinweise

• Führen Sie das Codelab zur API-Einrichtung durch, um ein Google Cloud-Projekt einzurichten und ein Dienstkonto zum Aufrufen der Cloud Channel API zu erstellen.

• Channel Services-Vorgänge

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

Wichtiger Hinweis :Für dieses Codelab benötigen Sie programmatischen Zugriff auf die DNS-Einträge der Kundendomain.

Für dieses Codelab wird außerdem davon ausgegangen, dass Sie das Codelab zur End-to-End-Bereitstellung für Workspace abgeschlossen haben.

Überblick

Die Überprüfung der Domain für die Google Workspace-Berechtigung umfasst mehrere API-Aufrufe.

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

Schritt 1: Auf die Site Verification API vorbereiten

• Rufen Sie in der Google Cloud Console den Abschnitt API-Bibliothek auf und aktivieren Sie die Site Verification API.
• Rufen Sie mit dem Super Admin-Konto Ihrer Reseller-Domain die Seite für die domainweite Delegierung auf.
  • Klicken Sie in der Zeile mit Ihrem Dienstkonto auf Bearbeiten.
  • Geben Sie https://www.googleapis.com/auth/siteverification in das Feld OAuth-Bereiche ein.
  • Klicken Sie auf Autorisieren.
• Installieren Sie die Site Verification API-Clientbibliothek.

Schritt 2: Bestätigungstoken abrufen

In diesem Codelab geht es um die gängigste Methode zur Bestätigung einer Domain: die Verwendung von TXT-DNS-Einträgen. Die Site Verification API unterstützt andere Bestätigungsmethoden.

Zum Abrufen des Tokens, das Sie als TXT-Eintrag platzieren, müssen Sie Tokens für type=INET_DOMAIN und verificationMethod=DNS_TXT abrufen.

Geben Sie im folgenden Code diese Variablen mit Ihren Informationen ein.

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

• customerDomain: Domain des Endkunden Wenn Sie dieses Codelab in der Test Partner Sales Console ausführen, achten Sie darauf, dass die Domain den Namenskonventionen für Domains entspricht.

C#

Folgende Importe werden verwendet:

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

Einfach loslegen (Go)

Folgende Importe werden verwendet:

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

Folgende Importe werden verwendet:

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

Über 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

Folgende Importe werden verwendet:

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)

Hinweis: Das generierte Token ist an den API-Aufrufer gebunden (den Super Admin Ihres Reseller-Kontos). Ihr Kunde kann seine Domain nicht durch Einfügen dieses Tokens in seine DNS-Einträge bestätigen.

Schritt 3: Bestätigungstoken platzieren

Schreiben Sie den Code, um das Token als TXT-Eintrag in die DNS-Einträge der Kundendomain aufzunehmen.

Für neue Domains ist dies ein guter Zeitpunkt, um die erforderlichen MX-Einträge für Gmail einzurichten.

Schritt 4: Domainbestätigung auslösen

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

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

Wenn der Aufruf ohne Fehler zurückgegeben wird, betrachtet die Site Verification API die Domain als bestätigt und alle E-Mail-Adressen im Feld owners der webResource gelten als bestätigter Inhaber.

Es kann etwa drei Stunden dauern, bis der Bestätigungsstatus im Google Workspace-Konto des Kunden angezeigt wird. Sie können die sofortige Weitergabe des Status erzwingen. Dazu legen Sie den Administrator des Kunden, der beim Aufruf von provisionCloudIdentity erstellt wurde, als owner von webResource fest.

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