Atelier de programmation: Automatiser la validation de domaine pour Google Workspace

Pourquoi automatiser la validation de domaine ?

Bien que l'API Cloud Channel vous permette de provisionner des droits d'accès Google Workspace à grande échelle, le client doit encore effectuer les actions suivantes pour activer les services.

1. Acceptez les conditions d'utilisation
2. Valider la propriété du domaine
3. Configurer les enregistrements MX

Les clients nouvellement créés doivent suivre une procédure guidée pour accéder à la console d'administration (sur admin.google.com) pour la première fois.

Si vous disposez d'un accès programmatique aux enregistrements DNS du domaine (par exemple, si vous avez revendu le domaine au client), vous pouvez automatiser les étapes 2 et 3 pour augmenter les taux d'activation, car ces étapes nécessitent généralement des connaissances techniques de la part d'un client indirect.

Cet atelier de programmation explique comment utiliser l'API Site Verification pour implémenter cette automatisation.

Avant de commencer

• Assurez-vous d'avoir suivi l'atelier de programmation sur la configuration de l'API pour configurer un projet Google Cloud et créer un compte de service pour appeler l'API Cloud Channel.

• Découvrez-en plus sur les opérations Channel Services.

• Nous vous recommandons d'utiliser la console Ventes partenaires de test pour cet atelier de programmation.

Important :Cet atelier de programmation nécessite un accès programmatique aux enregistrements DNS du domaine du client.

Il s'attend également à ce que vous ayez terminé l'atelier de programmation sur le provisionnement de bout en bout des espaces de travail.

Présentation

La validation des droits d'accès à Google Workspace pour le domaine implique plusieurs appels d'API.

L'API de validation de site n'est pas spécifique aux revendeurs. La validation du domaine est un signal utilisé dans divers produits Google (Search Console, Ads, etc.). La procédure décrite ici repose sur la définition du super-administrateur de votre domaine de revendeur en tant que "propriétaire" du domaine et sur la définition du premier administrateur du client en tant que copropriétaire. Pour en savoir plus sur ces concepts, consultez la page Premiers pas avec l'API Site Verification.

Étape 1: Préparez-vous pour l'API de validation de site

• Accédez à la section Bibliothèque d'API de la console Google Cloud et activez l'API Site Verification.
• Accédez à la page Délégation au niveau du domaine à l'aide du compte super-administrateur de votre domaine de revendeur.
  • Sur la ligne correspondant à votre compte de service, cliquez sur Modifier.
  • Saisissez https://www.googleapis.com/auth/siteverification dans le champ Champs d'application OAuth.
  • Cliquez sur Autoriser.
• Installez la bibliothèque cliente de l'API Site Verification.

Étape 2: Obtenez un jeton de validation

Cet atelier de programmation porte sur la méthode la plus courante pour valider un domaine: l'utilisation d'enregistrements DNS TXT. L'API Site Verification accepte d'autres méthodes de validation.

Pour récupérer le jeton que vous allez placer en tant qu'enregistrement TXT, vous devez obtenir des jetons pour type=INET_DOMAIN et verificationMethod=DNS_TXT.

Dans le code suivant, renseignez ces variables à l'aide de vos informations.

• jsonKeyFile : chemin d'accès au fichier de clé JSON généré lors de la création d'un compte de service.
• resellerAdminUser : adresse e-mail d'un super-administrateur de domaine de revendeur.

• customerDomain: domaine du client final Si vous exécutez cet atelier de programmation sur la console Ventes partenaires de test, assurez-vous que le domaine respecte les conventions de dénomination des domaines.

C#

À l'aide des importations suivantes:

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

Créez le client API et récupérez le jeton:

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

À l'aide des importations suivantes:

import (
  "context"
  "fmt"
  "os"

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

Créez le client API et récupérez le jeton:

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

À l'aide des importations suivantes:

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;

Créez le client API et récupérez le jeton:

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

En utilisant l'importation suivante:

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

Créez le client API et récupérez le jeton:

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

Créez le client API et récupérez le jeton:

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

À l'aide des importations suivantes:

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

Créez le client API et récupérez le jeton:

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

Remarque :Le jeton généré est lié à l'appelant de l'API (le super-administrateur de votre compte revendeur). Votre client ne peut pas valider son domaine en plaçant ce jeton dans ses enregistrements DNS.

Étape 3: Jeton de validation d'emplacement

Écrivez le code pour ajouter le jeton en tant qu'enregistrement TXT dans les enregistrements DNS du domaine du client.

Pour les nouveaux domaines, profitez-en pour configurer les enregistrements MX requis pour Gmail.

Étape 4: Déclencher la validation du domaine

Une fois le jeton placé en tant qu'enregistrement TXT, vous pouvez appeler l'API Site Verification pour déclencher la validation. Pour ce faire, appelez webResource.insert().

L'appel échoue et renvoie une erreur 400 si le jeton attendu est introuvable. Vous pouvez mettre en œuvre une stratégie d'intervalle exponentiel entre les tentatives jusqu'à ce que l'appel aboutisse pour compenser les retards de propagation DNS.

Si l'appel s'affiche sans erreur, l'API Site Verification considère que le domaine est validé et tous les e-mails du champ owners de webResource sont des propriétaires validés.

Un délai d'environ trois heures peut être nécessaire pour que l'état de validation soit appliqué au compte Google Workspace de votre client. Vous pouvez forcer la propagation instantanée de l'état en définissant l'administrateur du client (créé lorsque vous avez appelé provisionCloudIdentity) en tant que owner du 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")