Codelab: Automatiza la verificación de dominios para Google Workspace

¿Por qué automatizar la verificación del dominio?

Si bien la API de Cloud Channel te permite aprovisionar derechos de Google Workspace a gran escala, el cliente aún debe realizar las siguientes acciones para habilitar los servicios.

1. Acepta las Condiciones del Servicio
2. Verifica la propiedad del dominio
3. Configurar los registros MX

Un cliente recién creado seguirá un proceso de requisitos guiado cuando acceda a la Consola del administrador (en admin.google.com) por primera vez.

Si tienes acceso programático a los registros DNS del dominio (por ejemplo, si le revendiste el dominio al cliente), puedes automatizar los pasos 2 y 3 para aumentar los porcentajes de activación, ya que esos pasos suelen requerir conocimientos técnicos de un cliente al que se le revendió el dominio.

En este codelab, se explica cómo usar la API de Site Verification para implementar esta automatización.

Antes de comenzar

• Asegúrate de completar el codelab de configuración de la API para configurar un proyecto deGoogle Cloud y crear una cuenta de servicio para llamar a la API de Cloud Channel.

• Lee sobre las operaciones de los servicios de canal.

• Te recomendamos que uses la Consola de ventas para socios de prueba para este codelab.

Punto clave: Para realizar este codelab, debes tener acceso programático a los registros DNS del dominio del cliente.

En este codelab, también se espera que hayas terminado el codelab de aprovisionamiento de extremo a extremo de Workspace.

Descripción general

La verificación del dominio para el derecho de Google Workspace implica varias llamadas a la API.

La API de Site Verification no es específica para los revendedores. La verificación de dominio es un indicador que se usa en varios productos de Google (Search Console, Google Ads, etcétera). El proceso que se describe aquí se basa en configurar el administrador avanzado de tu dominio de comercializador como “propietario” del dominio y configurar el primer administrador de tu cliente como copropietario. Puedes obtener más información sobre esos conceptos en la página Cómo comenzar a usar la API de Site Verification.

Paso 1: Preparación para la API de Site Verification

• Ve a la sección Biblioteca de API en la Google Cloud consola y habilita la API de Site Verification.
• Ve a la página de delegación de todo el dominio con la cuenta de administrador avanzado de tu dominio de revendedor.
  • En la fila de tu cuenta de servicio, haz clic en Editar.
  • Ingresa https://www.googleapis.com/auth/siteverification en el campo OAuth Scopes.
  • Haz clic en Autorizar.
• Instala la biblioteca cliente de la API de Site Verification.

Paso 2: Obtén el token de verificación

En este codelab, se enfocará en la forma más común de verificar un dominio: con registros DNS de TXT. La API de Site Verification admite otros métodos de verificación.

Para recuperar el token que colocarás como un registro TXT, debes obtener tokens para type=INET_DOMAIN y verificationMethod=DNS_TXT.

En el siguiente código, completa estas variables con tu información.

• jsonKeyFile: Es la ruta de acceso al archivo de clave JSON que se generó cuando creaste una cuenta de servicio.
• resellerAdminUser: Es la dirección de correo electrónico de un administrador avanzado del dominio de un distribuidor.

• customerDomain: Es el dominio del cliente final. Si ejecutas este codelab en tu Console de ventas para socios de prueba, asegúrate de que el dominio siga las convenciones de nombres de dominio.

C#

Con las siguientes importaciones:

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

Crea el cliente de la API y recupera el 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

Con las siguientes importaciones:

import (
  "context"
  "fmt"
  "os"

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

Crea el cliente de la API y recupera el token:

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

Con las siguientes importaciones:

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 el cliente de la API y recupera el 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

Con la siguiente importación:

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

Crea el cliente de la API y recupera el 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 el cliente de la API y recupera el 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

Con las siguientes importaciones:

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

Crea el cliente de la API y recupera el 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)

Nota: El token generado está vinculado al llamador de la API (el administrador avanzado de tu cuenta de revendedor). Tu cliente no puede verificar su dominio colocando este token en sus registros DNS.

Paso 3: Coloca el token de verificación

Escribe el código para agregar el token como un registro TXT en los registros DNS del dominio del cliente.

En el caso de los dominios nuevos, este es un buen momento para configurar los registros MX necesarios para Gmail.

Paso 4: Activa la verificación del dominio

Una vez que el token se coloca como un registro TXT, puedes llamar a la API de Site Verification para activar la verificación. Para ello, llama a webResource.insert().

La llamada falla con un error 400 si no se encuentra el token esperado. Puedes implementar una estrategia de reintento de tiempo de espera exponencial hasta que la llamada se realice correctamente para compensar los retrasos en la propagación del DNS.

Si la llamada no muestra errores, la API de Site Verification considera que el dominio se verificó y que cualquier correo electrónico en el campo owners de webResource es un propietario verificado.

El estado de verificación puede tardar alrededor de 3 horas en propagarse a la cuenta de Google Workspace de tu cliente. Puedes forzar que el estado se propague de forma inmediata configurando el administrador del cliente (creado cuando llamaste a provisionCloudIdentity) como un owner del 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")