Codelab: Automatizar la verificación del dominio para Google Workspace

Ventajas de automatizar la verificación del dominio

Aunque la API Cloud Channel te permite aprovisionar los derechos del espacio de trabajo de Google a escala, el cliente tiene que seguir los pasos siguientes para habilitar los servicios.

1. Aceptar los términos del servicio
2. Verificar la propiedad del dominio
3. Configurar los registros MX

Un cliente recién creado seguirá un proceso guiado para acceder a la consola de administración (en admin.google.com) por primera vez.

Si tienes acceso mediante programación a los registros DNS del dominio (por ejemplo, si distribuyes el dominio al cliente), puedes automatizar los pasos 2 y 3 para aumentar las tasas de activación, ya que estos pasos requieren conocimientos técnicos. de un cliente de reventa.

En este codelab se explica cómo implementar la automatización mediante la API de verificación de sitios web.

Antes de empezar

• Completa el codelab de configuración de APIs para configurar un proyecto de Google Cloud y crear una cuenta de servicio para llamar a la API Cloud Channel.

• Consulta las operaciones de los servicios de canales.

• Te recomendamos que uses la Consola de Channel Services Console de este codelab.

Importante: Para usar este codelab, debes disponer de acceso mediante programación a los registros DNS del dominio del cliente.

Este codelab también espera que termines el codelab completo de aprovisionamiento del espacio de trabajo.

Información general

Verificar la propiedad del dominio de Google Workspace consiste en realizar varias llamadas a APIs.

La API de verificación de sitios no es específica para distribuidores. La verificación del dominio es una señal que se utiliza en varios productos de Google (Search Console, Ads, etc.). El proceso que se describe aquí depende de configurar al superadministrador de tu dominio de distribuidor como "propietario" del dominio y de configurar al primer administrador de tu cliente como copropietario. Puedes obtener más información sobre estos conceptos en la página de introducción a la API de verificación de sitios.

Paso 1: Prepararse para la API Site Verification

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

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

Este codelab se centrará en la forma más común de verificar un dominio: usar registros de DNS de TXT. La API de verificación del sitio web admite otros métodos de verificación.

Para obtener el token que incluirás como registro TXT, debes obtener tokens de type=INET_DOMAIN y verificationMethod=DNS_TXT.

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

• jsonKeyFile: la ruta al archivo de clave JSON que se genera al crear una cuenta de servicio.
• resellerAdminUser: la dirección de correo electrónico del superadministrador de un dominio de distribuidor.

• customerDomain: el dominio del cliente final. Si ejecutas este codelab en la Consola de Channel Services de prueba, asegúrate de que el dominio sigue las convenciones de nomenclatura de dominios.

C#

Mediante las importaciones siguientes:

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 obtén 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

Mediante las importaciones siguientes:

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

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

Crea el cliente de la API y obtén el 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

Mediante las importaciones siguientes:

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 obtén 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

Mediante la importación siguiente:

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

Crea el cliente de la API y obtén 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 obtén 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

Mediante las importaciones siguientes:

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

Crea el cliente de la API y obtén 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 API (el superadministrador de tu cuenta de distribuidor). El cliente no puede verificar su dominio colocando este token en sus registros DNS.

Paso 3: Haz un token de verificación

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

Ahora es un buen momento para configurar los registros MX necesarios para Gmail.

Paso 4: Activa la verificación del dominio

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

La llamada falla si se muestra un error 400 si no se encuentra el token esperado. Puedes implementar una estrategia de reintento exponencial y hasta que la llamada llegue correctamente a la espera de retrasos en la propagación de DNS.

Si la llamada se devuelve sin errores, la API de verificación del sitio web considera que el dominio está verificado, y todos los correos electrónicos en el campo owners de webResource son propietarios verificados.

El estado de verificación puede tardar hasta tres horas en propagarse a la cuenta de Google Workspace de tu cliente. Para forzar la retención de datos de forma instantánea, configura el administrador del cliente (creado cuando se llama aprovisionCloudIdentity ) comoowner dewebResource en tu teléfono Android.

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