Codelab: Automatische Domainbestätigung für Google Workspace

Vorteile der automatischen Domainbestätigung

Mit der Cloud Channel API können Sie Google Workspace Umfang hat, muss der Kunde noch Folgendes tun: um Dienste zu aktivieren.

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

Ein neu erstellter Kunde folgt einem geführten Anforderungsprozess, greifen Sie zum ersten Mal über admin.google.com auf die Admin-Konsole zu.

Wenn Sie programmatischen Zugriff auf die DNS-Einträge der Domain haben, z. B. wenn Sie die Domain an den Kunden weiterverkaufen, können Sie die Schritte 2 und 3 bis zum Aktivierungsraten erhöhen, da diese Schritte von Kunden eines Resellers.

In diesem Codelab wird erläutert, wie Sie mit der für diese Automatisierung.

Hinweise

• Stellen Sie sicher, dass Sie Codelab für die API-Einrichtung Google Cloud-Projekt erstellen und ein Dienstkonto erstellen, um die Cloud Channel API

• Channel Services-Vorgänge

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

Wichtig :Für dieses Codelab benötigen Sie programmatischen Zugriff auf den Kunden DNS-Einträge der Domain.

In diesem Codelab werden außerdem die Tests Codelab für die End-to-End-Bereitstellung von Workspace

Übersicht

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

Die Site Verification API ist nicht spezifisch für Reseller. Domain ist die Verifizierung ein Signal, das in verschiedenen Google-Produkten verwendet wird (Search Console, Anzeigen usw.). Der hier beschriebene Prozess basiert darauf, die Super Admin als „Inhaber“ und legen den ersten Administrator des Kunden fest. als Mitinhaber. Weitere Informationen zu diesen Konzepten finden Sie auf der Erste Schritte mit der Site Verification API Seite.

Schritt 1: Websiteüberprüfungs-API vorbereiten

• Wechseln Sie in der Google Cloud Console zum Abschnitt API-Bibliothek und aktivieren Sie die Site Verification API
• Gehen Sie zur Domainweite Delegationsseite über das Super Admin-Konto Ihrer Reseller-Domain.
  • Klicken Sie in der Zeile mit Ihrem Dienstkonto auf Bearbeiten.
  • Geben Sie https://www.googleapis.com/auth/siteverification in die OAuth-Bereiche.
  • Klicken Sie auf Autorisieren.
• Installieren Sie die Site Verification API-Clientbibliothek

Schritt 2: Bestätigungstoken abrufen

In diesem Codelab liegt der Schwerpunkt auf der gängigsten Methode zur Bestätigung einer Domain: der Verwendung von TXTDNS-Einträgen. Die Site Verification API unterstützt anderen 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.

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

• 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 auf Ihrem Testen Sie die Partner Sales Console und achten Sie darauf, dass die Domain der Domainbenennung entspricht Konventionen treffen.

C#

Dabei werden folgende Importe 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);

Go

Dabei werden folgende Importe 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

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

Mithilfe des folgenden Imports:

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

Dabei werden folgende Importe 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 mit dem API-Aufrufer (Super Admin Ihres Reseller-Kontos) verknüpft. Ihr Kunde kann seine Domain nicht durch Platzieren dieses Tokens bestätigen in ihren DNS-Einträgen.

Schritt 3: Bestätigungstoken platzieren

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

Für neue Domains ist dies ein guter Zeitpunkt, Erforderliche MX-Einträge für Gmail.

Schritt 4: Domainbestätigung auslösen

Nachdem das Token als TXT-Eintrag platziert wurde, können Sie die Methode Website Verification API, um die Überprüfung auszulösen. Dies ist erreicht durch einen Anruf webResource.insert()

Der Aufruf schlägt mit dem Fehler 400 fehl, wenn das erwartete Token nicht gefunden wird. Sie können Implementierung einer Strategie mit exponentiellem Backoff-Wiederholungsversuch, bis der Aufruf erfolgreich ist und Verzögerungen bei der DNS-Weitergabe.

Wenn beim Aufruf keine Fehler zurückgegeben werden, berücksichtigt die Site Verification API die zu bestätigende Domain und alle E-Mail-Adressen im Feld owners der webResource ist ein bestätigter Inhaber.

Es kann bis zu drei Stunden dauern, bis der Bestätigungsstatus wirksam wird mit dem Google Workspace-Konto Ihres Kunden. Sie können erzwingen, dass der Status sofort weitergegeben werden, indem Sie den Administrator des Kunden festlegen. Dieser wurde beim Aufrufen von provisionCloudIdentity) als owner der webResource.

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