Codelab: automazione della verifica del dominio per Google Workspace

Perché automatizzare la verifica del dominio?

Mentre l'API Cloud Channel consente di eseguire il provisioning dei diritti di Google Workspace su larga scala, il cliente deve comunque eseguire le seguenti azioni per abilitare i servizi.

  1. Accetta i Termini di servizio
  2. Verifica la proprietà del dominio
  3. Configura i record MX

Un cliente appena creato seguirà una procedura di requisiti guidata quando accede per la prima volta alla Console di amministrazione (su admin.google.com).

Se hai accesso programmatico ai record DNS del dominio (ad esempio, se hai rivenduto il dominio al cliente), puoi automatizzare i passaggi 2 e 3 per aumentare i tassi di attivazione, poiché tali passaggi richiedono in genere una conoscenza tecnica. da un cliente del rivenditore.

Questo codelab spiega come utilizzare l'API Site Verification per implementare questa automazione.

Prima di iniziare

Questo codelab ti aspetta anche di completare il codelab end-to-end del Workspace.

Panoramica

La verifica del dominio per il diritto di area di lavoro di Google comporta diverse chiamate API.

Passaggi per automatizzare la verifica del dominio

L'API Site Verification non è specifica per i rivenditori. La verifica del dominio è un segnale utilizzato in vari prodotti Google (console di ricerca, annunci ecc.). Il processo descritto di seguito si basa sull'impostazione del super amministratore del dominio del tuo rivenditore come "proprietario" del dominio e impostazione del primo amministratore del cliente come comproprietario. Puoi trovare ulteriori informazioni su questi concetti nella pagina Guida introduttiva all'utilizzo dell'API Site Verification.

Passaggio 1: preparati per l'API Site Verification

Passaggio 2: acquista il token di verifica

Questo codelab si concentrarà sul modo più comune per verificare un dominio: utilizzando i record DNS TXT. L'API Site Verification supporta altri metodi di verifica.

Per recuperare il token che inserirai come record TXT, devi procurarti i token per type=INET_DOMAIN e verificationMethod=DNS_TXT.

Nel codice seguente, inserisci queste variabili utilizzando le tue informazioni.

  • jsonKeyFile: il percorso del file di chiave JSON generato al momento della creazione di un account di servizio.
  • resellerAdminUser: l'indirizzo email di un super amministratore del dominio di un rivenditore.
  • customerDomain: il dominio del cliente finale. Se esegui questo codelab nella console di Test Channel Services, assicurati che il dominio segua le convenzioni di denominazione dei domini.

C#

Utilizzando le seguenti importazioni:

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

Crea il client API e recupera il token:

// 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

Utilizzando le seguenti importazioni:

import (
  "context"
  "fmt"
  "io/ioutil"

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

Crea il client API e recupera il token:

ctx := context.Background()

// Set up credentials with user impersonation
jsonKey, _ := ioutil.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

Utilizzando le seguenti importazioni:

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;

Crea il client API e recupera il token:

// 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

Utilizzando la seguente importazione:

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

Crea il client API e recupera il token:

// 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

Crea il client API e recupera il token:

// 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

Utilizzando le seguenti importazioni:

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

Crea il client API e recupera il token:

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

Passaggio 3: inserisci il token di verifica

Scrivi il codice per aggiungere il token come record TXT nei record DNS del dominio del cliente.

Per i nuovi domini, è il momento giusto per configurare i MX record richiesti per Gmail.

Passaggio 4: attiva la verifica del dominio

Dopo aver inserito il token come record TXT, puoi chiamare l'API Site Verification per attivare la verifica. Questo risultato può essere ottenuto chiamando webResource.insert().

La chiamata ha esito negativo e restituisce un errore 400 se non viene trovato il token previsto. Puoi implementare una strategia di backoff esponenziale prima di avviare la chiamata per ritardi di propagazione DNS.

Se la chiamata viene restituita senza errori, l'API di verifica del sito considera il dominio da verificare e qualsiasi email nel campo owners di webResource è un proprietario verificato.

La propagazione dello stato di verifica all'account Google Workspace di un cliente potrebbe richiedere circa tre ore. Puoi forzare lo stato necessario a procurare impostando l'amministratore del cliente (creato quando hai chiamato provisionCloudIdentity ) comeowner dellewebResource sul dispositivo mobile.

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