किसी ग्राहक का प्रावधान करें

इस ट्यूटोरियल में, Reseller API का इस्तेमाल करके किसी ग्राहक को सेवा देने का तरीका बताया गया है.

किसी ग्राहक को सही तरीके से सेवा देने के लिए, कई ऐसे चरण पूरे करने होते हैं जो एक-दूसरे पर निर्भर होते हैं. ये चरण, Google Workspace प्लैटफ़ॉर्म के कई एपीआई में फैले होते हैं.

Google Workspace ग्राहक बनाने के लिए इस्तेमाल किए गए एपीआई का फ़्लो.
इमेज 1. Google Workspace के ग्राहक को सेवा देने के लिए, ये चरण पूरे करें

ऊपर दिए गए डायग्राम में दिखाया गया है कि किसी ग्राहक को सेवा देने के लिए, हर चरण में किन एपीआई का इस्तेमाल किया जाता है:

  • डोमेन की पुष्टि करने वाला टोकन रखने के लिए, Site Verification API का इस्तेमाल करें.
  • ग्राहक बनाने के लिए, Reseller API का इस्तेमाल करें.
  • Directory API का इस्तेमाल करके, पहला उपयोगकर्ता बनाएं और उसे एडमिन बनाएं.
  • सदस्यता बनाने के लिए, Reseller API का इस्तेमाल करें.
  • डोमेन की पुष्टि करने के लिए, Site Verification API का इस्तेमाल करें.

ज़रूरी शर्तें

  • Google Reseller का डोमेन इंस्टेंस.
  • Google Workspace पार्टनर समझौते पर हस्ताक्षर किया गया हो.

अपना एनवायरमेंट सेट अप करने का तरीका

इस ट्यूटोरियल को पूरा करने के लिए, अपना एनवायरमेंट सेट अप करें.

एपीआई चालू करना

Google API का इस्तेमाल करने से पहले, आपको उन्हें Google Cloud प्रोजेक्ट में चालू करना होगा. एक ही Google Cloud प्रोजेक्ट में, एक या उससे ज़्यादा एपीआई चालू किए जा सकते हैं.

सेवा खाता बनाना

सेवा खाता एक खास तरह का खाता होता है, जिसका इस्तेमाल कोई ऐप्लिकेशन करता है. यह खाता किसी व्यक्ति का नहीं होता. सेवा खाते का इस्तेमाल, रोबोट खाते से डेटा ऐक्सेस करने या कार्रवाइयां करने के लिए किया जा सकता है. इसके अलावा, इसका इस्तेमाल Google Workspace या Cloud Identity के उपयोगकर्ताओं की ओर से डेटा ऐक्सेस करने के लिए भी किया जा सकता है. ज़्यादा जानकारी के लिए, सेवा खातों के बारे में जानकारी लेख पढ़ें.

Google Cloud कंसोल

  1. Google Cloud console में, मेन्यू > आईएएम और एडमिन > सेवा खाते पर जाएं.

    सेवा खातों पर जाएं

  2. सेवा खाता बनाएं पर क्लिक करें.
  3. सेवा खाते की जानकारी भरें. इसके बाद, बनाएं और जारी रखें पर क्लिक करें.
  4. ज़रूरी नहीं: अपने सेवा खाते को भूमिकाएं असाइन करें, ताकि उसे आपके Google Cloud प्रोजेक्ट के संसाधनों का ऐक्सेस मिल सके. ज़्यादा जानकारी के लिए, संसाधनों का ऐक्सेस देना, उसमें बदलाव करना, और उसे रद्द करना लेख पढ़ें.
  5. जारी रखें पर क्लिक करें.
  6. उन उपयोगकर्ताओं या ग्रुप के नाम डालें जिनके पास इस सेवा खाते को मैनेज करने और इससे जुड़ी कार्रवाइयां करने का ऐक्सेस है. हालांकि, यह ज़रूरी नहीं है. ज़्यादा जानकारी के लिए, सेवा खाते के डुप्लीकेट को मैनेज करना लेख पढ़ें.
  7. हो गया पर क्लिक करें. सेवा खाते का ईमेल पता नोट कर लें.

gcloud सीएलआई

  1. सेवा खाता बनाएं: 
    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name="SERVICE_ACCOUNT_NAME"
  2. ज़रूरी नहीं: अपने सेवा खाते को भूमिकाएं असाइन करें, ताकि उसे आपके Google Cloud प्रोजेक्ट के संसाधनों का ऐक्सेस मिल सके. ज़्यादा जानकारी के लिए, संसाधनों का ऐक्सेस देना, उसमें बदलाव करना, और उसे रद्द करना लेख पढ़ें.

किसी सेवा खाते के लिए क्रेडेंशियल बनाना

आपको सार्वजनिक/निजी पासकोड के जोड़े के तौर पर क्रेडेंशियल पाने होंगे. इन क्रेडेंशियल का इस्तेमाल, आपका कोड करता है. इससे आपके ऐप्लिकेशन में सेवा खाते की कार्रवाइयों को अनुमति दी जाती है.
  1. Google Cloud console में, मेन्यू > आईएएम और एडमिन > सेवा खाते पर जाएं.

    सेवा खातों पर जाएं

  2. अपना सेवा खाता चुनें.
  3. कुंजियां > कुंजी जोड़ें > नई कुंजी बनाएं पर क्लिक करें.
  4. JSON चुनें. इसके बाद, बनाएं पर क्लिक करें.

    आपकी नई सार्वजनिक/निजी कुंजी की जोड़ी जनरेट करके आपकी मशीन पर एक नई फ़ाइल के तौर पर डाउनलोड की जाती है. डाउनलोड की गई JSON फ़ाइल को अपनी वर्किंग डायरेक्ट्री में credentials.json के तौर पर सेव करें. यह फ़ाइल, इस कुंजी की सिर्फ़ एक कॉपी है. अपनी कुंजी को सुरक्षित तरीके से सेव करने के बारे में जानकारी के लिए, सेवा खाते की कुंजियां मैनेज करना लेख पढ़ें.

  5. बंद करें पर क्लिक करें.

किसी सेवा खाते के लिए, डोमेन के सभी उपयोगकर्ताओं के डेटा का ऐक्सेस देने की सुविधा सेट अप करना

Google Workspace संगठन में उपयोगकर्ताओं की ओर से एपीआई कॉल करने के लिए, आपके सेवा खाते को पूरे डोमेन के लिए अधिकार सौंपने की अनुमति मिलनी चाहिए. यह अनुमति, Google Workspace Admin console में सुपर एडमिन खाते से मिलती है. ज़्यादा जानकारी के लिए, किसी सेवा खाते को पूरे डोमेन का ऐक्सेस देना लेख पढ़ें.
  1. Google Cloud console में, मेन्यू > आईएएम और एडमिन > सेवा खाते पर जाएं.

    सेवा खातों पर जाएं

  2. अपना सेवा खाता चुनें.
  3. ऐडवांस सेटिंग दिखाएं पर क्लिक करें.
  4. "पूरे डोमेन के लिए उपयोगकर्ता की भूमिका सौंपना" में जाकर, अपने सेवा खाते का "क्लाइंट आईडी" ढूंढें. क्लाइंट आईडी की वैल्यू को क्लिपबोर्ड पर कॉपी करने के लिए, कॉपी करें पर क्लिक करें.

  5. अगर आपके पास Google Workspace खाते का सुपर एडमिन ऐक्सेस है, तो Google Workspace Admin Console देखें पर क्लिक करें. इसके बाद, सुपर एडमिन खाते का इस्तेमाल करके साइन इन करें और इन चरणों को पूरा करें.

    अगर आपके पास Google Workspace खाते का सुपर एडमिन ऐक्सेस नहीं है, तो उस खाते के सुपर एडमिन से संपर्क करें. साथ ही, उन्हें अपने सेवा खाते का क्लाइंट आईडी और OAuth स्कोप की सूची भेजें, ताकि वे Admin console में ये चरण पूरे कर सकें.

    1. Google Admin console में, मेन्यू &gt सुरक्षा &gt ऐक्सेस और डेटा कंट्रोल &gt एपीआई कंट्रोल पर जाएं.

      एपीआई कंट्रोल पर जाएं

    2. पूरे डोमेन के लिए डेटा का ऐक्सेस मैनेज करें पर क्लिक करें.
    3. नया जोड़ें पर क्लिक करें.
    4. "क्लाइंट आईडी" फ़ील्ड में, वह क्लाइंट आईडी चिपकाएं जिसे आपने पहले कॉपी किया था.
    5. "OAuth स्कोप" फ़ील्ड में, अपने ऐप्लिकेशन के लिए ज़रूरी स्कोप की कॉमा-सेपरेटेड लिस्ट डालें. यह स्कोप का वही सेट है जिसे आपने OAuth सहमति स्क्रीन को कॉन्फ़िगर करते समय तय किया था.
    6. अनुमति दें पर क्लिक करें.

पुष्टि किए गए क्रेडेंशियल की मदद से सेवा ऑब्जेक्ट बनाना

किसी भी Google API का इस्तेमाल शुरू करने के लिए, आपको सबसे पहले अपने ऐप्लिकेशन में पुष्टि करने की सुविधा और क्रेडेंशियल सेट अप करने होंगे. Google की क्लाइंट लाइब्रेरी, यह काम आपकी ओर से करती हैं. सभी लाइब्रेरी में क्रेडेंशियल ऑब्जेक्ट बनाने के पैटर्न होते हैं. इस ऑब्जेक्ट को सभी एपीआई का ऐक्सेस दिया जा सकता है और इसे हर सेवा में पास किया जा सकता है. किसी ऐप्लिकेशन के पास आम तौर पर क्रेडेंशियल का एक ही सेट होना चाहिए. साथ ही, उसे Google API के साथ सभी इंटरैक्शन के लिए, सिर्फ़ एक क्लाउड प्रोजेक्ट का इस्तेमाल करना चाहिए.

उस JSON कुंजी फ़ाइल का इस्तेमाल करें जिसे आपने सेवा खाता बनाते समय जनरेट किया था.

Python
import sys
from apiclient.discovery import build
from apiclient.http import HttpError
from oauth2client.service_account import ServiceAccountCredentials

############## REPLACE WITH YOUR OWN VALUES ####################
JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json'
RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com'
CUSTOMER_DOMAIN = 'example.com'
CUSTOMER_SITE = 'https://www.example.com'
################################################################

# Full List of scopes:
# https://developers.google.com/identity/protocols/googlescopes
OAUTH2_SCOPES = [
    'https://reseller.googleapis.com/auth/apps.order',
    'https://reseller.googleapis.com/auth/siteverification',
    'https://reseller.googleapis.com/auth/admin.directory.user',
]

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    JSON_PRIVATE_KEY_FILE, OAUTH2_SCOPES).create_delegated(RESELLER_ADMIN_USER)

reseller_service = build(
    serviceName='reseller', version='v1', credentials=credentials)

directory_service = build(
    serviceName='admin', version='directory_v1', credentials=credentials)

verification_service = build(
    serviceName='siteVerification', version='v1', credentials=credentials)
Java
// OAuth2 and HTTP
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpResponseException;
import com.google.api.client.json.jackson2.JacksonFactory;
// Directory API
import com.google.api.services.admin.directory.Directory;
import com.google.api.services.admin.directory.DirectoryScopes;
import com.google.api.services.admin.directory.model.User;
import com.google.api.services.admin.directory.model.UserMakeAdmin;
import com.google.api.services.admin.directory.model.UserName;
// Reseller API
import com.google.api.services.reseller.Reseller;
import com.google.api.services.reseller.ResellerScopes;
import com.google.api.services.reseller.model.Address;
import com.google.api.services.reseller.model.Customer;
import com.google.api.services.reseller.model.RenewalSettings;
import com.google.api.services.reseller.model.Seats;
import com.google.api.services.reseller.model.Subscription;
// Site Verification API
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;
// Java library imports
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;
import java.util.List;

/**
 * This is a basic example of provisioning a Google Workspace customer.
 */
public class CodelabExample {
  // Full List of scopes:
  // https://developers.google.com/identity/protocols/googlescopes
  private static final List<String> OAUTH2_SCOPES = Arrays.asList(
    ResellerScopes.APPS_ORDER,
    SiteVerificationScopes.SITEVERIFICATION,
    DirectoryScopes.ADMIN_DIRECTORY_USER
  );

  /***************** REPLACE WITH YOUR OWN VALUES ********************************/
  public static final String JSON_PRIVATE_KEY_FILE = "path/to/json_key_file.json";
  public static final String RESELLER_ADMIN_USER = "admin@yourresellerdomain.com";
  public static final String CUSTOMER_DOMAIN = "example.com";
  public static final String CUSTOMER_SITE = "https://www.example.com/";
  /*******************************************************************************/

  public static void main(String[] args)
      throws IOException, GeneralSecurityException, FileNotFoundException {
    // Instantiate services with authenticated credentials
    GoogleCredential jsonCredentials = GoogleCredential
      .fromStream(new FileInputStream(JSON_PRIVATE_KEY_FILE));
    GoogleCredential credentials = new GoogleCredential.Builder()
      .setTransport(GoogleNetHttpTransport.newTrustedTransport())
      .setJsonFactory(JacksonFactory.getDefaultInstance())
      .setServiceAccountScopes(OAUTH2_SCOPES)
      .setServiceAccountUser(RESELLER_ADMIN_USER)
      .setServiceAccountPrivateKey(jsonCredentials.getServiceAccountPrivateKey())
      .setServiceAccountId(jsonCredentials.getServiceAccountId())
      .build();

    Reseller resellerService = new Reseller.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();

    Directory directoryService = new Directory.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();

    SiteVerification verificationService = new SiteVerification.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();
C#
// OAuth2 and HTTP
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
// Reseller API
using Google.Apis.Reseller.v1;
using Google.Apis.Reseller.v1.Data;
// Directory API
using Google.Apis.Admin.Directory.directory_v1;
using User = Google.Apis.Admin.Directory.directory_v1.Data.User;
using UserName = Google.Apis.Admin.Directory.directory_v1.Data.UserName;
using UserMakeAdmin = Google.Apis.Admin.Directory.directory_v1.Data.UserMakeAdmin;
//Site Verification API
using Google.Apis.SiteVerification.v1;
using Google.Apis.SiteVerification.v1.Data;
// System imports
using System;
using System.IO;

class CodelabExample
{
    // Full List of scopes:
    // https://developers.google.com/identity/protocols/googlescopes
    static string[] OAUTH2_SCOPES = {
        ResellerService.Scope.AppsOrder,
        DirectoryService.Scope.AdminDirectoryUser,
        SiteVerificationService.Scope.Siteverification
    };

    /***************** REPLACE WITH YOUR OWN VALUES ********************************/
    public static String JSON_PRIVATE_KEY_FILE = "path/to/json_key_file.json";
    public static String RESELLER_ADMIN_USER = "admin@yourresellerdomain.com";
    public static String CUSTOMER_DOMAIN = "example.com";
    public static String CUSTOMER_SITE = "https://www.example.com/";
    /*******************************************************************************/

    static void Main(string[] args)
    {
        GoogleCredential credential;

        using (var stream = new FileStream(JSON_PRIVATE_KEY_FILE, FileMode.Open, FileAccess.Read))
        {
            credential = GoogleCredential
                .FromStream(stream)
                .CreateScoped(OAUTH2_SCOPES)
                .CreateWithUser(RESELLER_ADMIN_USER);
        }

        var resellerService = new ResellerService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });

        var directoryService = new DirectoryService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });

        var verificationService = new SiteVerificationService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });
PHP
// https://developers.google.com/api-client-library/php/
require_once 'vendor/autoload.php';

// Full List of scopes:
// https://developers.google.com/identity/protocols/googlescopes
$OAUTH2_SCOPES = [
  Google_Service_Reseller::APPS_ORDER,
  Google_Service_SiteVerification::SITEVERIFICATION,
  Google_Service_Directory::ADMIN_DIRECTORY_USER,
];

######### REPLACE WITH YOUR OWN VALUES ###############
$JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json';
$RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com';
$CUSTOMER_DOMAIN = 'example.com';
$CUSTOMER_SITE = 'https://www.example.com/';
######################################################

$client = new Google_Client();
$client->setAuthConfig($JSON_PRIVATE_KEY_FILE);
$client->setSubject($RESELLER_ADMIN_USER);
$client->setScopes($OAUTH2_SCOPES);

$resellerService = new Google_Service_Reseller($client);
$directoryService = new Google_Service_Directory($client);
$verificationService = new Google_Service_SiteVerification($client);
Ruby
require 'googleauth'
require 'google/apis/reseller_v1'
require 'google/apis/site_verification_v1'
require 'google/apis/admin_directory_v1'

# Full List of scopes:
# https://developers.google.com/identity/protocols/googlescopes
OAUTH2_SCOPES = [
  'https://reseller.googleapis.com/auth/apps.order',
  'https://reseller.googleapis.com/auth/admin.directory.user',
  'https://reseller.googleapis.com/auth/siteverification',
]

####### REPLACE WITH YOUR OWN VALUES ###############
JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json'
RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com'
CUSTOMER_DOMAIN = 'example.com'
CUSTOMER_SITE = 'https://www.example.com/'
####################################################

credentials = Google::Auth::ServiceAccountCredentials.make_creds(
  json_key_io: File.open(JSON_PRIVATE_KEY_FILE),
  scope: OAUTH2_SCOPES)
credentials.sub = RESELLER_ADMIN_USER

Google::Apis::RequestOptions.default.authorization = credentials

reseller_service = Google::Apis::ResellerV1::ResellerService.new
directory_service = Google::Apis::AdminDirectoryV1::DirectoryService.new
verification_service = Google::Apis::SiteVerificationV1::SiteVerificationService.new
Node.js
// NOTE: This script needs googleapis 28.0.0 or later as it uses promises
const {google} = require('googleapis');

// ############## REPLACE WITH YOUR OWN VALUES ####################
const JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json';
const RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com';
const CUSTOMER_DOMAIN = 'example.com';
const CUSTOMER_SITE = 'https://www.example.com/';
// ################################################################

// Full List of scopes: https://developers.google.com/identity/protocols/googlescopes
const OAUTH2_SCOPES = [
  'https://reseller.googleapis.com/auth/apps.order',
  'https://reseller.googleapis.com/auth/siteverification',
  'https://reseller.googleapis.com/auth/admin.directory.user',
];

const authJWT = new google.auth.JWT({
  keyFile: JSON_PRIVATE_KEY_FILE,
  scopes: OAUTH2_SCOPES,
  subject: RESELLER_ADMIN_USER,
});

const resellerService = google.reseller({version: 'v1', auth: authJWT});
const directoryService = google.admin({version: 'directory_v1', auth: authJWT});
const verificationService = google.siteVerification({version: 'v1', auth: authJWT});

डोमेन की पुष्टि करने की प्रोसेस शुरू करना

यह चरण वैकल्पिक है. हालांकि, अगर आपके पास ग्राहक के डोमेन की पुष्टि करने की सुविधा है, तो हम आपको ऐसा करने का सुझाव देते हैं. यह चरण, ट्यूटोरियल के आखिर में पूरा होता है. इसके लिए, आपको डोमेन की पुष्टि करनी होगी.

अगर आपने ग्राहक के डोमेन की पुष्टि नहीं की, तो उस पर ये पाबंदियां लागू होंगी:

साइट की पुष्टि करने वाला टोकन वापस पाने के लिए, यह तरीका अपनाएं:

  1. साइट की पुष्टि करने वाला टोकन पाने के लिए, Site Verification API का इस्तेमाल करें. यह पुष्टि नहीं की जा सकती कि किसी डोमेन की पहले पुष्टि की गई है या नहीं. हालांकि, बिना किसी समस्या के साइटों की कई बार पुष्टि की जा सकती है. INET_DOMAIN या SITE टाइप में से किसी एक की पुष्टि करने के आधार पर, verificationMethod पैरामीटर अलग-अलग होते हैं. इनमें से कोई एक विकल्प चुनें:

    • टाइप INET_DOMAIN के लिए, इनमें से किसी एक verificationMethod पैरामीटर का इस्तेमाल करें:

      • DNS_TXT
      • DNS_CNAME

      टोकन वापस पाने के इस उदाहरण में, INET_DOMAIN टाइप का इस्तेमाल किया गया है:

      Python
      # Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
response = verification_service.webResource().getToken(
    body={
        'site': {
            'type': 'INET_DOMAIN',
            'identifier': CUSTOMER_DOMAIN
        },
        'verificationMethod': 'DNS_TXT'
    }).execute()
print(response)
      Java
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
SiteVerificationWebResourceGettokenRequest.Site getTokenSite =
    new SiteVerificationWebResourceGettokenRequest.Site()
        .setType("INET_DOMAIN")
        .setIdentifier(CUSTOMER_DOMAIN);

SiteVerificationWebResourceGettokenRequest request =
    new SiteVerificationWebResourceGettokenRequest()
        .setVerificationMethod("DNS_TXT")
        .setSite(getTokenSite);

SiteVerificationWebResourceGettokenResponse getTokenResponse =
    verificationService.webResource().getToken(request).execute();
System.out.println("Site Verification Token: " + getTokenResponse.getToken());
      C#
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
SiteVerificationWebResourceGettokenRequest.SiteData getTokenSite =
    new SiteVerificationWebResourceGettokenRequest.SiteData()
    {
        Type = "INET_DOMAIN",
        Identifier = CUSTOMER_DOMAIN
    };

SiteVerificationWebResourceGettokenRequest request =
    new SiteVerificationWebResourceGettokenRequest()
    {
        VerificationMethod = "DNS_TXT",
        Site = getTokenSite
    };

SiteVerificationWebResourceGettokenResponse getTokenResponse =
    verificationService.WebResource.GetToken(request).Execute();
Console.WriteLine("Site Verification Token: {0}", getTokenResponse.Token);
      PHP
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
$body =
new Google_Service_SiteVerification_SiteVerificationWebResourceGettokenRequest([
  'verificationMethod' => 'DNS_TXT',
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN
  ]
]);
$response = $verificationService->webResource->getToken($body);
print_r ($response);
      Ruby
      # Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
request = Google::Apis::SiteVerificationV1::GetWebResourceTokenRequest.new(
  site: {
    type: 'INET_DOMAIN',
    identifier: CUSTOMER_DOMAIN
  },
  verification_method: 'DNS_TXT'
)

response = verification_service.get_web_resource_token(request)
puts response.inspect
      Node.js
      /**
 * Retrieve the site verification token and place it according to:
 * https://developers.google.com/site-verification/v1/getting_started#tokens
 */
const getTokenPromise = verificationService.webResource.getToken({
  requestBody: {
    site: {
      type: 'INET_DOMAIN',
      identifier: CUSTOMER_DOMAIN,
    },
    verificationMethod: 'DNS_TXT',
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

    • टाइप SITE के लिए, इनमें से किसी एक verificationMethod पैरामीटर का इस्तेमाल करें:

      • FILE
      • META

      टोकन वापस पाने के इस उदाहरण में, FILE पुष्टि करने के तरीके के साथ SITE टाइप का इस्तेमाल किया गया है. SITE पुष्टि के टाइप का इस्तेमाल करते समय, आपको आइडेंटिफ़ायर के पहले http:// या https:// लगाना होगा.

      Python
      # Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
response = verification_service.webResource().getToken(
    body={
        'site': {
            'type': 'SITE',
            'identifier': CUSTOMER_SITE
        },
        'verificationMethod': 'FILE'
    }).execute()
print(response)
      Java
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
SiteVerificationWebResourceGettokenRequest.Site getTokenSite =
    new SiteVerificationWebResourceGettokenRequest.Site()
        .setType("SITE")
        .setIdentifier(CUSTOMER_SITE);

SiteVerificationWebResourceGettokenRequest request =
    new SiteVerificationWebResourceGettokenRequest()
        .setVerificationMethod("FILE")
        .setSite(getTokenSite);

SiteVerificationWebResourceGettokenResponse getTokenResponse =
    verificationService.webResource().getToken(request).execute();
System.out.println("Site Verification Token: " + getTokenResponse.getToken());
      C#
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
SiteVerificationWebResourceGettokenRequest.SiteData getTokenSite =
    new SiteVerificationWebResourceGettokenRequest.SiteData()
    {
        Type = "SITE",
        Identifier = CUSTOMER_SITE
    };

SiteVerificationWebResourceGettokenRequest request =
    new SiteVerificationWebResourceGettokenRequest()
    {
        VerificationMethod = "FILE",
        Site = getTokenSite
    };

SiteVerificationWebResourceGettokenResponse getTokenResponse =
    verificationService.WebResource.GetToken(request).Execute();
Console.WriteLine("Site Verification Token: {0}", getTokenResponse.Token);
      PHP
      // Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
$body =
new Google_Service_SiteVerification_SiteVerificationWebResourceGettokenRequest([
  'verificationMethod' => 'FILE',
  'site' => [
    'type' => 'SITE',
    'identifier' => $CUSTOMER_DOMAIN
  ]
]);
$response = $verificationService->webResource->getToken($body);
print_r($response);
      Ruby
      # Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
request = Google::Apis::SiteVerificationV1::GetWebResourceTokenRequest.new(
  site: {
    type: 'SITE',
    identifier: CUSTOMER_SITE
  },
  verification_method: 'FILE'
)

response = verification_service.get_web_resource_token(request)
puts response.inspect
      Node.js
      /**
 * Retrieve the site verification token and place it according to:
 * https://developers.google.com/site-verification/v1/getting_started#tokens
 */
const getTokenPromise = verificationService.webResource.getToken({
  requestBody: {
    site: {
      type: 'SITE',
      identifier: CUSTOMER_SITE,
    },
    verificationMethod: 'FILE',
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

  2. साइट की पुष्टि करने वाले टोकन को डीएनएस रिकॉर्ड या साइट में रखें.

Reseller API का इस्तेमाल करके ग्राहक बनाना

  1. Customers.Get तरीके का इस्तेमाल करके, यह पता लगाएं कि कोई ग्राहक पहले से Google Workspace में मौजूद है या नहीं:

    Python
    # Determine if customer domain already has Google Workspace
try:
  response = reseller_service.customers().get(
      customerId=CUSTOMER_DOMAIN).execute()
  print('Customer already exists if call succeeds')
  sys.exit()
except HttpError as error:
  if int(error.resp['status']) == 404:
    print('Domain available for Google Workspace creation')
  else:
    raise
    Java
    // Determine if customer domain already has Google Workspace
try {
  resellerService.customers().get(CUSTOMER_DOMAIN).execute();
  System.out.println("Customer already exists if call succeeds");
  System.exit(0);
} catch (HttpResponseException e) {
    if (e.getStatusCode() == 404) {
      System.out.println("Domain available for Google Workspace creation");
    } else { 
      throw e; 
    }
}
    C#
    // Determine if customer domain already has Google Workspace
try
{
    resellerService.Customers.Get(CUSTOMER_DOMAIN).Execute();
    Console.WriteLine("Customer already exists if call succeeds");
    Environment.Exit(0);
}
catch (Google.GoogleApiException e) {
    if (e.Error.Code == 404)
    {
        Console.WriteLine("Domain available for Google Workspace creation");
    } else throw e;
}
    PHP
    // Determine if customer domain already has Google Workspace
try {
  $response = $resellerService->customers->get($CUSTOMER_DOMAIN);
  exit('Customer already exists if call succeeds');
} catch(Google_Service_Exception $e) {
  if ($e->getErrors()[0]['reason'] == 'notFound'){
    print ("Domain available for Google Workspace creation\n");
  } else {
    throw $e;
  }
}
    Ruby
    # Determine if customer domain already has Google Workspace
begin
  reseller_service.get_customer(CUSTOMER_DOMAIN)
  abort('Customer already exists if call succeeds')
rescue Google::Apis::ClientError => ex
  if ex.status_code == 404
    puts 'Domain available for Google Workspace creation'
  else
    raise ex
  end
end
    Node.js
    // Determine if customer domain already has Google Workspace
const getCustomerPromise = resellerService.customers.get({
  customerId: CUSTOMER_DOMAIN
}).then(() => {
  throw new Error('Customer already exists');
}, resErr => {
  if (resErr.code === 404) {
    console.log('Domain available for Google Workspace creation');
  } else {
    throw resErr;
  }
});

  2. जवाब के हिसाब से, यह तरीका अपनाएं:

    • अगर ग्राहक मौजूद नहीं है, तो customers.get तरीके से HTTP 404 गड़बड़ी वाला कोड दिखता है. अगले चरण पर जाएं. यहां आपको Google Workspace में ग्राहकों का रिकॉर्ड बनाना होगा.

    • अगर customers.get तरीके से कोई गड़बड़ी नहीं होती है, तो यह पता लगाएं कि ग्राहक आपका है या नहीं. इसके लिए, alternateEmail प्रॉपर्टी के लिए जवाब की बॉडी देखें. अगर alternateEmail प्रॉपर्टी मौजूद नहीं है, तो आपको ग्राहक और उसकी सदस्यताएं ट्रांसफ़र करनी होंगी.

  3. Google Workspace में ग्राहक का रिकॉर्ड बनाएं. आपको ग्राहक का रिकॉर्ड बनाना होगा. इसके बाद ही, इन दिशा-निर्देशों का पालन करके उस ग्राहक के लिए सदस्यताएं बनाई जा सकती हैं:

    • alternateEmail और customerDomain एक ही डोमेन पर नहीं हो सकते.
    • postalAddress.countryCode, दो वर्णों वाला आईएसओ देश कोड होना चाहिए.

    यहां ग्राहक का रिकॉर्ड बनाने का उदाहरण दिया गया है:

    Python
    # Create customer resource
response = reseller_service.customers().insert(
    body={
        'customerDomain': CUSTOMER_DOMAIN,
        'alternateEmail': 'marty.mcfly@gmail.com',
        'postalAddress': {
            'contactName': 'Marty McFly',
            'organizationName': 'Acme Corp',
            'postalCode': '10009',
            'countryCode': 'US',
        }
    }).execute()
print(response)
    Java
    // Create customer resource
Address address = new Address()
  .setContactName("Marty McFly")
  .setOrganizationName("Acme Corp")
  .setCountryCode("US")
  .setPostalCode("10009");

Customer customer = new Customer()
  .setCustomerDomain(CUSTOMER_DOMAIN)
  .setAlternateEmail("marty.mcfly@gmail.com")
  .setPostalAddress(address);

Customer customerResponse = resellerService.customers()
  .insert(customer).execute();
System.out.println("Created Customer:\n" + customerResponse);
    C#
    // Create customer resource
Address address = new Address()
{
    ContactName = "Marty McFly",
    OrganizationName = "Acme Corp",
    CountryCode = "US",
    PostalCode = "10009"
};

Customer customer = new Customer()
{
    CustomerDomain = CUSTOMER_DOMAIN,
    AlternateEmail = "marty.mcfly@gmail.com",
    PostalAddress = address
};

Customer customerResponse = resellerService.Customers.Insert(customer).Execute();
Console.WriteLine("Created Customer:\n{0}", customerResponse);
    PHP
    // Create customer resource
$customer = new Google_Service_Reseller_Customer([
  'customerDomain' => $CUSTOMER_DOMAIN,
  'alternateEmail' => 'marty.mcfly@gmail.com',
  'postalAddress' => [
    'contactName' => 'Marty McFly',
    'organizationName' => 'Acme Corp',
    'countryCode' => 'US',
    'postalCode' => '10009'
  ]
]);
$response = $resellerService->customers->insert($customer);
print_r ($response);
    Ruby
    # Create customer resource
customer = Google::Apis::ResellerV1::Customer.new(
  customer_domain: CUSTOMER_DOMAIN,
  alternate_email: 'marty.mcfly@gmail.com',
  postal_address: {
    contact_name: 'Marty McFly',
    organization_name: 'Acme Corp',
    country_code: 'US',
    postal_code: '10009'})

response = reseller_service.insert_customer(customer)
puts response.inspect
    Node.js
    // Create customer resource
const insertCustomerPromise = resellerService.customers.insert({
  requestBody: {
    customerDomain: CUSTOMER_DOMAIN,
    alternateEmail: 'marty.mcfly@gmail.com',
    postalAddress: {
      contactName: 'Marty McFly',
      organizationName: 'Acme Corp',
      postalCode: '10009',
      countryCode: 'US',
    }
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

एडमिन SDK API का इस्तेमाल करके पहला एडमिन उपयोगकर्ता बनाना

किसी ग्राहक के लिए सेवा चालू करने के बाद, आपको पहला उपयोगकर्ता बनाना होगा. साथ ही, उसे तुरंत डोमेन सुपर एडमिन के तौर पर अपग्रेड करना होगा, ताकि ग्राहक नई सेवाओं को ऐक्सेस कर सके और लागू होने वाली सेवा की शर्तें स्वीकार कर सके.

  1. पहला उपयोगकर्ता बनाएं और उसका पासवर्ड सेट करें. पासवर्ड काफ़ी मुश्किल होने चाहिए और उनमें कम से कम आठ वर्ण होने चाहिए. ज़्यादा जानकारी के लिए, user संसाधन देखें.

    Python
    # Create first admin user
response = directory_service.users().insert(
    body={
        'primaryEmail': 'marty.mcfly@' + CUSTOMER_DOMAIN,
        'name': {
            'givenName': 'Marty',
            'familyName': 'McFly',
        },
        'password': 'Timecircuit88'
    }).execute()
print(response)
    Java
    // Create first admin user
String userEmail = "marty.mcfly@" + CUSTOMER_DOMAIN;

UserName name = new UserName();
name.setGivenName("Marty");
name.setFamilyName("McFly");

User user = new User();
user.setPrimaryEmail(userEmail);
user.setPassword("TimeCircuit88");
user.setName(name);

User userResponse = directoryService.users().insert(user).execute();
System.out.println("Created User:\n" + userResponse);
    C#
    // Create first admin user
String userEmail = "marty.mcfly@" + CUSTOMER_DOMAIN;

UserName name = new UserName()
{
    GivenName = "Marty",
    FamilyName = "McFly"
};

User user = new User()
{
    PrimaryEmail = userEmail,
    Password = "TimeCircuit88",
    Name = name
};

User userResponse = directoryService.Users.Insert(user).Execute();
Console.WriteLine("Created User:\n{0}", userResponse);
    PHP
    // Create first admin user
$user = new Google_Service_Directory_User([
  'primaryEmail' => 'marty.mcfly@' . $CUSTOMER_DOMAIN,
  'password' => 'Timecircuit88',
  'name' => [
    'givenName' => 'Marty',
    'familyName' => 'McFly',
    'fullName' => 'Marty McFly'
  ]
]);
$response = $directoryService->users->insert($user);
print_r ($response);
    Ruby
    # Create first admin user
user = Google::Apis::AdminDirectoryV1::User.new(
  name: {
    given_name: 'Marty',
    family_name: 'McFly',
    full_name: 'Marty McFly'
  },
  password: 'Timecircuit88',
  primary_email: 'marty.mcfly@' + CUSTOMER_DOMAIN,
)

response = directory_service.insert_user(user)
puts response.inspect
    Node.js
    // Create first admin user
const insertUserPromise = directoryService.users.insert({
  requestBody: {
    primaryEmail: `marty.mcfly@${CUSTOMER_DOMAIN}`,
    name: {
      givenName: 'Marty',
      familyName: 'McFly',
    },
    password: 'Timecircuit88',
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

    अगर उपयोगकर्ता बनाने के लिए किए गए कॉल से HTTP 409 मिलता है, तो हो सकता है कि उपयोगकर्ता नाम पहले से ही Google के उपभोक्ता खाते के तौर पर मौजूद हो.

  2. उपयोगकर्ता को सुपर एडमिन की भूमिका पर अपग्रेड करें:

    Python
    # Promote user to admin status
response = directory_service.users().makeAdmin(
    userKey='marty.mcfly@' + CUSTOMER_DOMAIN, body={
        'status': True
    }).execute()
    Java
    // Promote user to admin status
UserMakeAdmin admin = new UserMakeAdmin();
admin.setStatus(true);

directoryService.users().makeAdmin(userEmail, admin).execute();
System.out.println("User promoted to Admin");
    C#
    // Promote user to admin status
UserMakeAdmin admin = new UserMakeAdmin()
{
    Status = true
};
directoryService.Users.MakeAdmin(admin, userEmail).Execute();
Console.WriteLine("User promoted to Admin");
    PHP
    // Promote user to admin status
$makeAdmin = new Google_Service_Directory_UserMakeAdmin([
  'status' => true
]);
$directoryService->users->makeAdmin(
  'marty.mcfly@' . $CUSTOMER_DOMAIN,
  $makeAdmin
);
    Ruby
    # Promote user to admin status
admin_status = Google::Apis::AdminDirectoryV1::UserMakeAdmin.new(
  status: true
)

response = directory_service.make_user_admin('marty.mcfly@' + CUSTOMER_DOMAIN, admin_status)
    Node.js
    // Promote user to admin status
const makeAdminPromise = directoryService.users.makeAdmin({
  userKey: `marty.mcfly@${CUSTOMER_DOMAIN}`,
  requestBody: {
    status: true
  }
});

किसी ग्राहक के लिए Google Workspace की सदस्यता बनाना

किसी ग्राहक के लिए सदस्यता बनाते समय, आपको इस ग्राहक के लिए purchaseOrderId फ़ील्ड में, इंटरनल ट्रांज़ैक्शन आईडी या आइडेंटिफ़ायर डालना होगा. खास तर्कों और वैल्यू के बारे में ज़्यादा जानने के लिए, सदस्यताएं मैनेज करना लेख पढ़ें.

  1. सदस्यता बनाने के लिए, Subscriptions.Insert कॉल का इस्तेमाल करें. यहां दिए गए उदाहरण में, ANNUAL_YEARLY_PAY सदस्यता का इस्तेमाल किया गया है:

    Python
    # Create subscription resource
response = reseller_service.subscriptions().insert(
    customerId=CUSTOMER_DOMAIN,
    body={
        'customerId': CUSTOMER_DOMAIN,
        'skuId': '1010020027',
        'plan': {
            'planName': 'ANNUAL_MONTHLY_PAY',
        },
        'seats': {
            'numberOfSeats': 5,
        },
        'renewalSettings': {  # only relevant for annual plans
            'renewalType': 'RENEW_CURRENT_USERS_MONTHLY_PAY'
        }
    }).execute()
print(response)
    Java
    // Create subscription resource
Seats seats = new Seats()
  .setNumberOfSeats(5);

Subscription.Plan plan = new Subscription.Plan()
  .setPlanName("ANNUAL_YEARLY_PAY");

RenewalSettings renewalSettings = new RenewalSettings()
  .setRenewalType("RENEW_CURRENT_USERS_MONTHLY_PAY");

Subscription subscription = new Subscription()
  .setCustomerId(CUSTOMER_DOMAIN)
  .setSeats(seats)
  .setPlan(plan)
  .setSkuId("1010020027")
  .setRenewalSettings(renewalSettings);

Subscription subscriptionResponse = resellerService.subscriptions()
  .insert(CUSTOMER_DOMAIN, subscription).execute();
System.out.println("Created Subscription:\n" + subscriptionResponse);
    C#
    // Create subscription resource
Seats seats = new Seats()
{
    NumberOfSeats = 5
};

Subscription.PlanData plan = new Subscription.PlanData()
{
    PlanName = "ANNUAL_YEARLY_PAY"
};

RenewalSettings renewalSettings = new RenewalSettings()
{
    RenewalType = "RENEW_CURRENT_USERS_MONTHLY_PAY"
};

Subscription subscription = new Subscription()
{
    CustomerId = CUSTOMER_DOMAIN,
    Seats = seats,
    Plan = plan,
    SkuId = "1010020027",
    RenewalSettings = renewalSettings
};

Subscription subscriptionResponse = resellerService.Subscriptions
    .Insert(subscription, CUSTOMER_DOMAIN).Execute();
Console.WriteLine("Created Subscription:\n" + subscriptionResponse);
    PHP
    // Create subscription resource
$subscription = new Google_Service_Reseller_Subscription([
  'customerId' => $CUSTOMER_DOMAIN,
  'skuId' => '1010020027',
  'plan' => [
    'planName' => 'ANNUAL_MONTHLY_PAY'
  ],
  'seats' => [
    'numberOfSeats' => '5'
  ],
  'renewalSettings' => [
    'renewalType' => 'RENEW_CURRENT_USERS_MONTHLY_PAY'
  ]
]);
$response = $resellerService->subscriptions->insert(
  $CUSTOMER_DOMAIN,
  $subscription
);
print_r ($response);
    Ruby
    # Create subscription resource
subscription = Google::Apis::ResellerV1::Subscription.new(
  customer_id: CUSTOMER_DOMAIN,
  sku_id: '1010020027',
  plan: {
    plan_name: 'ANNUAL_MONTHLY_PAY'
  },
  seats: {
    number_of_seats: 5,
  },
  renewal_settings: {
    renewal_type: 'RENEW_CURRENT_USERS_MONTHLY_PAY'
  }
)

response = reseller_service.insert_subscription(CUSTOMER_DOMAIN, subscription)
puts response.inspect
    Node.js
    // Create subscription resource
const insertSubscriptionPromise = resellerService.subscriptions.insert({
  customerId: CUSTOMER_DOMAIN,
  requestBody: {
    customerId: CUSTOMER_DOMAIN,
    skuId: '1010020027',
    plan: {
      planName: 'ANNUAL_MONTHLY_PAY',
    },
    seats: {
      numberOfSeats: 5,
    },
    renewalSettings: { // only relevant for annual plans
      renewalType: 'RENEW_CURRENT_USERS_MONTHLY_PAY',
    }
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

  2. सदस्यताएं तब तक SUSPENDED स्थिति में रहती हैं, जब तक ग्राहक एडमिन लॉग इन करके सेवा की शर्तें स्वीकार नहीं कर लेता. ग्राहक के एडमिन को पहली बार लॉगिन करने पर, सेवा की शर्तों वाले पेज पर रीडायरेक्ट किया जाता है. ऐसा तब होता है, जब वे Google की किसी प्रॉपर्टी (जैसे, Gmail या Google Drive) को ऐक्सेस करते हैं.

डोमेन की पुष्टि करना और डोमेन के मालिकों को असाइन करना

यह चरण वैकल्पिक है. हालांकि, अगर आपके पास ग्राहक के डोमेन की पुष्टि करने की सुविधा है, तो हम आपको ऐसा करने का सुझाव देते हैं. Site Verification API webResource.insert() कॉल, डोमेन की पुष्टि करता है. साथ ही, उस डोमेन के लिए उन मालिकों को असाइन करता है जिन्हें आपने अनुरोध के मुख्य हिस्से के owners[] पैरामीटर में बताया है.

यहां दिए गए उदाहरण में, INET_DOMAIN की पुष्टि करने का तरीका बताया गया है:

Python
# Verify domain and designate domain owners
response = verification_service.webResource().insert(
    verificationMethod='DNS_TXT',
    body={
        'site': {
            'type': 'INET_DOMAIN',
            'identifier': CUSTOMER_DOMAIN
        },
        'owners': ['marty.mcfly@' + CUSTOMER_DOMAIN]
    }).execute()
print(response)
Java
// Verify domain and designate domain owners
SiteVerificationWebResourceResource.Site verifySite =
      new SiteVerificationWebResourceResource.Site()
            .setIdentifier(CUSTOMER_DOMAIN)
            .setType("INET_DOMAIN");

List<String> owners = Arrays.asList(userEmail);

SiteVerificationWebResourceResource resource =
  new SiteVerificationWebResourceResource()
        .setSite(verifySite)
        .setOwners(owners);

SiteVerificationWebResourceResource verifyResponse = 
  verificationService.webResource().insert("DNS_TXT", resource).execute();
System.out.println("Site Verification Web Resource:\n" + verifyResponse);
C#
// Verify domain and designate domain owners
SiteVerificationWebResourceResource.SiteData verifySite =
      new SiteVerificationWebResourceResource.SiteData()
      {
          Identifier = CUSTOMER_DOMAIN,
          Type = "INET_DOMAIN"
      };

string[] owners = { userEmail };

SiteVerificationWebResourceResource resource =
  new SiteVerificationWebResourceResource()
  {
      Site = verifySite,
      Owners = owners
  };

SiteVerificationWebResourceResource verifyResponse =
    verificationService.WebResource.Insert(resource, "DNS_TXT").Execute();
Console.WriteLine("Site Verification Web Resource:\n" + verifyResponse);
PHP
// Verify domain and designate domain owners
$body =
new Google_Service_SiteVerification_SiteVerificationWebResourceResource([
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN,
  ],
  'owners' => ['marty.mcfly@' . $CUSTOMER_DOMAIN]
]);

$response = $verificationService->webResource->insert('DNS_TXT', $body);
print_r ($response);
Ruby
# Verify domain and designate domain owners
webResource = Google::Apis::SiteVerificationV1::SiteVerificationWebResourceResource.new(
  site: {
    type: 'INET_DOMAIN',
    identifier: CUSTOMER_DOMAIN
  },
  owners: ['marty.mcfly@' + CUSTOMER_DOMAIN]
)

response = verification_service.insert_web_resource('DNS_TXT', webResource)
puts response.inspect
Node.js
// Verify domain and designate domain owners
const verifyDomainPromise = verificationService.webResource.insert({
  verificationMethod: 'DNS_TXT',
  requestBody: {
    site: {
      type: 'INET_DOMAIN',
      identifier: CUSTOMER_DOMAIN,
    },
    owners: [`marty.mcfly@${CUSTOMER_DOMAIN}`],
  }
}).then(({data}) => {
  console.log(data);
  return data;
});

अगर यह कॉल पूरा होता है, तो HTTP 200 कोड मिलता है. अगर webResource.insert() डोमेन की पुष्टि नहीं कर पाता है, तो यह HTTP 400-लेवल का गड़बड़ी कोड दिखाता है. जब तक डोमेन की पुष्टि नहीं हो जाती, तब तक बैकऑफ़ डिले के साथ webResource.insert() कॉल को फिर से शुरू करें.

पूरी जानकारी का इस्तेमाल करना

यहां Google Workspace के किसी ग्राहक के लिए, पूरा कोड दिया गया है:

Python
"""This is a basic example of provisioning a Google Workspace customer.
"""
import sys
from apiclient.discovery import build
from apiclient.http import HttpError
from oauth2client.service_account import ServiceAccountCredentials

############## REPLACE WITH YOUR OWN VALUES ####################
JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json'
RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com'
CUSTOMER_DOMAIN = 'example.com'
CUSTOMER_SITE = 'https://www.example.com'
################################################################

# Full List of scopes:
# https://developers.google.com/identity/protocols/googlescopes
OAUTH2_SCOPES = [
    'https://reseller.googleapis.com/auth/apps.order',
    'https://reseller.googleapis.com/auth/siteverification',
    'https://reseller.googleapis.com/auth/admin.directory.user',
]

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    JSON_PRIVATE_KEY_FILE, OAUTH2_SCOPES).create_delegated(RESELLER_ADMIN_USER)

reseller_service = build(
    serviceName='reseller', version='v1', credentials=credentials)

directory_service = build(
    serviceName='admin', version='directory_v1', credentials=credentials)

verification_service = build(
    serviceName='siteVerification', version='v1', credentials=credentials)

# Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
response = verification_service.webResource().getToken(
    body={
        'site': {
            'type': 'INET_DOMAIN',
            'identifier': CUSTOMER_DOMAIN
        },
        'verificationMethod': 'DNS_TXT'
    }).execute()
print(response)

# Determine if customer domain already has Google Workspace
try:
  response = reseller_service.customers().get(
      customerId=CUSTOMER_DOMAIN).execute()
  print('Customer already exists if call succeeds')
  sys.exit()
except HttpError as error:
  if int(error.resp['status']) == 404:
    print('Domain available for Google Workspace creation')
  else:
    raise

# Create customer resource
response = reseller_service.customers().insert(
    body={
        'customerDomain': CUSTOMER_DOMAIN,
        'alternateEmail': 'marty.mcfly@gmail.com',
        'postalAddress': {
            'contactName': 'Marty McFly',
            'organizationName': 'Acme Corp',
            'postalCode': '10009',
            'countryCode': 'US',
        }
    }).execute()
print(response)

# Create first admin user
response = directory_service.users().insert(
    body={
        'primaryEmail': 'marty.mcfly@' + CUSTOMER_DOMAIN,
        'name': {
            'givenName': 'Marty',
            'familyName': 'McFly',
        },
        'password': 'Timecircuit88'
    }).execute()
print(response)

# Promote user to admin status
response = directory_service.users().makeAdmin(
    userKey='marty.mcfly@' + CUSTOMER_DOMAIN, body={
        'status': True
    }).execute()

# Create subscription resource
response = reseller_service.subscriptions().insert(
    customerId=CUSTOMER_DOMAIN,
    body={
        'customerId': CUSTOMER_DOMAIN,
        'skuId': '1010020027',
        'plan': {
            'planName': 'ANNUAL_MONTHLY_PAY',
        },
        'seats': {
            'numberOfSeats': 5,
        },
        'renewalSettings': {  # only relevant for annual plans
            'renewalType': 'RENEW_CURRENT_USERS_MONTHLY_PAY'
        }
    }).execute()
print(response)

# Verify domain and designate domain owners
response = verification_service.webResource().insert(
    verificationMethod='DNS_TXT',
    body={
        'site': {
            'type': 'INET_DOMAIN',
            'identifier': CUSTOMER_DOMAIN
        },
        'owners': ['marty.mcfly@' + CUSTOMER_DOMAIN]
    }).execute()
print(response)
Java
// OAuth2 and HTTP
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpResponseException;
import com.google.api.client.json.jackson2.JacksonFactory;
// Directory API
import com.google.api.services.admin.directory.Directory;
import com.google.api.services.admin.directory.DirectoryScopes;
import com.google.api.services.admin.directory.model.User;
import com.google.api.services.admin.directory.model.UserMakeAdmin;
import com.google.api.services.admin.directory.model.UserName;
// Reseller API
import com.google.api.services.reseller.Reseller;
import com.google.api.services.reseller.ResellerScopes;
import com.google.api.services.reseller.model.Address;
import com.google.api.services.reseller.model.Customer;
import com.google.api.services.reseller.model.RenewalSettings;
import com.google.api.services.reseller.model.Seats;
import com.google.api.services.reseller.model.Subscription;
// Site Verification API
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;
// Java library imports
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;
import java.util.List;

/**
 * This is a basic example of provisioning a Google Workspace customer.
 */
public class CodelabExample {
  // Full List of scopes:
  // https://developers.google.com/identity/protocols/googlescopes
  private static final List<String> OAUTH2_SCOPES = Arrays.asList(
    ResellerScopes.APPS_ORDER,
    SiteVerificationScopes.SITEVERIFICATION,
    DirectoryScopes.ADMIN_DIRECTORY_USER
  );

  /***************** REPLACE WITH YOUR OWN VALUES ********************************/
  public static final String JSON_PRIVATE_KEY_FILE = "path/to/json_key_file.json";
  public static final String RESELLER_ADMIN_USER = "admin@yourresellerdomain.com";
  public static final String CUSTOMER_DOMAIN = "example.com";
  public static final String CUSTOMER_SITE = "https://www.example.com/";
  /*******************************************************************************/

  public static void main(String[] args)
      throws IOException, GeneralSecurityException, FileNotFoundException {
    // Instantiate services with authenticated credentials
    GoogleCredential jsonCredentials = GoogleCredential
      .fromStream(new FileInputStream(JSON_PRIVATE_KEY_FILE));
    GoogleCredential credentials = new GoogleCredential.Builder()
      .setTransport(GoogleNetHttpTransport.newTrustedTransport())
      .setJsonFactory(JacksonFactory.getDefaultInstance())
      .setServiceAccountScopes(OAUTH2_SCOPES)
      .setServiceAccountUser(RESELLER_ADMIN_USER)
      .setServiceAccountPrivateKey(jsonCredentials.getServiceAccountPrivateKey())
      .setServiceAccountId(jsonCredentials.getServiceAccountId())
      .build();

    Reseller resellerService = new Reseller.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();

    Directory directoryService = new Directory.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();

    SiteVerification verificationService = new SiteVerification.Builder(
        credentials.getTransport(),
        credentials.getJsonFactory(),
        credentials).setApplicationName("Google Workspace Creator").build();

    // Retrieve the site verification token and place it according to:
    // https://developers.google.com/site-verification/v1/getting_started#tokens
    SiteVerificationWebResourceGettokenRequest.Site getTokenSite =
        new SiteVerificationWebResourceGettokenRequest.Site()
            .setType("INET_DOMAIN")
            .setIdentifier(CUSTOMER_DOMAIN);

    SiteVerificationWebResourceGettokenRequest request =
        new SiteVerificationWebResourceGettokenRequest()
            .setVerificationMethod("DNS_TXT")
            .setSite(getTokenSite);

    SiteVerificationWebResourceGettokenResponse getTokenResponse =
        verificationService.webResource().getToken(request).execute();
    System.out.println("Site Verification Token: " + getTokenResponse.getToken());

    // Determine if customer domain already has Google Workspace
    try {
      resellerService.customers().get(CUSTOMER_DOMAIN).execute();
      System.out.println("Customer already exists if call succeeds");
      System.exit(0);
    } catch (HttpResponseException e) {
        if (e.getStatusCode() == 404) {
          System.out.println("Domain available for Google Workspace creation");
        } else { 
          throw e; 
        }
    }

    // Create customer resource
    Address address = new Address()
      .setContactName("Marty McFly")
      .setOrganizationName("Acme Corp")
      .setCountryCode("US")
      .setPostalCode("10009");

    Customer customer = new Customer()
      .setCustomerDomain(CUSTOMER_DOMAIN)
      .setAlternateEmail("marty.mcfly@gmail.com")
      .setPostalAddress(address);

    Customer customerResponse = resellerService.customers()
      .insert(customer).execute();
    System.out.println("Created Customer:\n" + customerResponse);

    // Create first admin user
    String userEmail = "marty.mcfly@" + CUSTOMER_DOMAIN;

    UserName name = new UserName();
    name.setGivenName("Marty");
    name.setFamilyName("McFly");

    User user = new User();
    user.setPrimaryEmail(userEmail);
    user.setPassword("TimeCircuit88");
    user.setName(name);

    User userResponse = directoryService.users().insert(user).execute();
    System.out.println("Created User:\n" + userResponse);

    // Promote user to admin status
    UserMakeAdmin admin = new UserMakeAdmin();
    admin.setStatus(true);

    directoryService.users().makeAdmin(userEmail, admin).execute();
    System.out.println("User promoted to Admin");

    // Create subscription resource
    Seats seats = new Seats()
      .setNumberOfSeats(5);

    Subscription.Plan plan = new Subscription.Plan()
      .setPlanName("ANNUAL_YEARLY_PAY");

    RenewalSettings renewalSettings = new RenewalSettings()
      .setRenewalType("RENEW_CURRENT_USERS_MONTHLY_PAY");

    Subscription subscription = new Subscription()
      .setCustomerId(CUSTOMER_DOMAIN)
      .setSeats(seats)
      .setPlan(plan)
      .setSkuId("1010020027")
      .setRenewalSettings(renewalSettings);

    Subscription subscriptionResponse = resellerService.subscriptions()
      .insert(CUSTOMER_DOMAIN, subscription).execute();
    System.out.println("Created Subscription:\n" + subscriptionResponse);

    // Verify domain and designate domain owners
    SiteVerificationWebResourceResource.Site verifySite =
          new SiteVerificationWebResourceResource.Site()
                .setIdentifier(CUSTOMER_DOMAIN)
                .setType("INET_DOMAIN");

    List<String> owners = Arrays.asList(userEmail);

    SiteVerificationWebResourceResource resource =
      new SiteVerificationWebResourceResource()
            .setSite(verifySite)
            .setOwners(owners);

    SiteVerificationWebResourceResource verifyResponse = 
      verificationService.webResource().insert("DNS_TXT", resource).execute();
    System.out.println("Site Verification Web Resource:\n" + verifyResponse);
  }
}
C#
// OAuth2 and HTTP
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
// Reseller API
using Google.Apis.Reseller.v1;
using Google.Apis.Reseller.v1.Data;
// Directory API
using Google.Apis.Admin.Directory.directory_v1;
using User = Google.Apis.Admin.Directory.directory_v1.Data.User;
using UserName = Google.Apis.Admin.Directory.directory_v1.Data.UserName;
using UserMakeAdmin = Google.Apis.Admin.Directory.directory_v1.Data.UserMakeAdmin;
//Site Verification API
using Google.Apis.SiteVerification.v1;
using Google.Apis.SiteVerification.v1.Data;
// System imports
using System;
using System.IO;

class CodelabExample
{
    // Full List of scopes:
    // https://developers.google.com/identity/protocols/googlescopes
    static string[] OAUTH2_SCOPES = {
        ResellerService.Scope.AppsOrder,
        DirectoryService.Scope.AdminDirectoryUser,
        SiteVerificationService.Scope.Siteverification
    };

    /***************** REPLACE WITH YOUR OWN VALUES ********************************/
    public static String JSON_PRIVATE_KEY_FILE = "path/to/json_key_file.json";
    public static String RESELLER_ADMIN_USER = "admin@yourresellerdomain.com";
    public static String CUSTOMER_DOMAIN = "example.com";
    public static String CUSTOMER_SITE = "https://www.example.com/";
    /*******************************************************************************/

    static void Main(string[] args)
    {
        GoogleCredential credential;

        using (var stream = new FileStream(JSON_PRIVATE_KEY_FILE, FileMode.Open, FileAccess.Read))
        {
            credential = GoogleCredential
                .FromStream(stream)
                .CreateScoped(OAUTH2_SCOPES)
                .CreateWithUser(RESELLER_ADMIN_USER);
        }

        var resellerService = new ResellerService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });

        var directoryService = new DirectoryService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });

        var verificationService = new SiteVerificationService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
        });

        // Retrieve the site verification token and place it according to:
        // https://developers.google.com/site-verification/v1/getting_started#tokens
        SiteVerificationWebResourceGettokenRequest.SiteData getTokenSite =
            new SiteVerificationWebResourceGettokenRequest.SiteData()
            {
                Type = "INET_DOMAIN",
                Identifier = CUSTOMER_DOMAIN
            };

        SiteVerificationWebResourceGettokenRequest request =
            new SiteVerificationWebResourceGettokenRequest()
            {
                VerificationMethod = "DNS_TXT",
                Site = getTokenSite
            };

        SiteVerificationWebResourceGettokenResponse getTokenResponse =
            verificationService.WebResource.GetToken(request).Execute();
        Console.WriteLine("Site Verification Token: {0}", getTokenResponse.Token);

        // Determine if customer domain already has Google Workspace
        try
        {
            resellerService.Customers.Get(CUSTOMER_DOMAIN).Execute();
            Console.WriteLine("Customer already exists if call succeeds");
            Environment.Exit(0);
        }
        catch (Google.GoogleApiException e) {
            if (e.Error.Code == 404)
            {
                Console.WriteLine("Domain available for Google Workspace creation");
            } else throw e;
        }

        // Create customer resource
        Address address = new Address()
        {
            ContactName = "Marty McFly",
            OrganizationName = "Acme Corp",
            CountryCode = "US",
            PostalCode = "10009"
        };

        Customer customer = new Customer()
        {
            CustomerDomain = CUSTOMER_DOMAIN,
            AlternateEmail = "marty.mcfly@gmail.com",
            PostalAddress = address
        };

        Customer customerResponse = resellerService.Customers.Insert(customer).Execute();
        Console.WriteLine("Created Customer:\n{0}", customerResponse);

        // Create first admin user
        String userEmail = "marty.mcfly@" + CUSTOMER_DOMAIN;

        UserName name = new UserName()
        {
            GivenName = "Marty",
            FamilyName = "McFly"
        };

        User user = new User()
        {
            PrimaryEmail = userEmail,
            Password = "TimeCircuit88",
            Name = name
        };

        User userResponse = directoryService.Users.Insert(user).Execute();
        Console.WriteLine("Created User:\n{0}", userResponse);

        // Promote user to admin status
        UserMakeAdmin admin = new UserMakeAdmin()
        {
            Status = true
        };
        directoryService.Users.MakeAdmin(admin, userEmail).Execute();
        Console.WriteLine("User promoted to Admin");

        // Create subscription resource
        Seats seats = new Seats()
        {
            NumberOfSeats = 5
        };

        Subscription.PlanData plan = new Subscription.PlanData()
        {
            PlanName = "ANNUAL_YEARLY_PAY"
        };

        RenewalSettings renewalSettings = new RenewalSettings()
        {
            RenewalType = "RENEW_CURRENT_USERS_MONTHLY_PAY"
        };

        Subscription subscription = new Subscription()
        {
            CustomerId = CUSTOMER_DOMAIN,
            Seats = seats,
            Plan = plan,
            SkuId = "1010020027",
            RenewalSettings = renewalSettings
        };

        Subscription subscriptionResponse = resellerService.Subscriptions
            .Insert(subscription, CUSTOMER_DOMAIN).Execute();
        Console.WriteLine("Created Subscription:\n" + subscriptionResponse);

        // Verify domain and designate domain owners
        SiteVerificationWebResourceResource.SiteData verifySite =
              new SiteVerificationWebResourceResource.SiteData()
              {
                  Identifier = CUSTOMER_DOMAIN,
                  Type = "INET_DOMAIN"
              };

        string[] owners = { userEmail };

        SiteVerificationWebResourceResource resource =
          new SiteVerificationWebResourceResource()
          {
              Site = verifySite,
              Owners = owners
          };

        SiteVerificationWebResourceResource verifyResponse =
            verificationService.WebResource.Insert(resource, "DNS_TXT").Execute();
        Console.WriteLine("Site Verification Web Resource:\n" + verifyResponse);
    }
}
PHP
// https://developers.google.com/api-client-library/php/
require_once 'vendor/autoload.php';

// Full List of scopes:
// https://developers.google.com/identity/protocols/googlescopes
$OAUTH2_SCOPES = [
  Google_Service_Reseller::APPS_ORDER,
  Google_Service_SiteVerification::SITEVERIFICATION,
  Google_Service_Directory::ADMIN_DIRECTORY_USER,
];

######### REPLACE WITH YOUR OWN VALUES ###############
$JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json';
$RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com';
$CUSTOMER_DOMAIN = 'example.com';
$CUSTOMER_SITE = 'https://www.example.com/';
######################################################

$client = new Google_Client();
$client->setAuthConfig($JSON_PRIVATE_KEY_FILE);
$client->setSubject($RESELLER_ADMIN_USER);
$client->setScopes($OAUTH2_SCOPES);

$resellerService = new Google_Service_Reseller($client);
$directoryService = new Google_Service_Directory($client);
$verificationService = new Google_Service_SiteVerification($client);

// Retrieve the site verification token and place it according to:
// https://developers.google.com/site-verification/v1/getting_started#tokens
$body =
new Google_Service_SiteVerification_SiteVerificationWebResourceGettokenRequest([
  'verificationMethod' => 'DNS_TXT',
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN
  ]
]);
$response = $verificationService->webResource->getToken($body);
print_r ($response);

// Determine if customer domain already has Google Workspace
try {
  $response = $resellerService->customers->get($CUSTOMER_DOMAIN);
  exit('Customer already exists if call succeeds');
} catch(Google_Service_Exception $e) {
  if ($e->getErrors()[0]['reason'] == 'notFound'){
    print ("Domain available for Google Workspace creation\n");
  } else {
    throw $e;
  }
}

// Create customer resource
$customer = new Google_Service_Reseller_Customer([
  'customerDomain' => $CUSTOMER_DOMAIN,
  'alternateEmail' => 'marty.mcfly@gmail.com',
  'postalAddress' => [
    'contactName' => 'Marty McFly',
    'organizationName' => 'Acme Corp',
    'countryCode' => 'US',
    'postalCode' => '10009'
  ]
]);
$response = $resellerService->customers->insert($customer);
print_r ($response);

// Create first admin user
$user = new Google_Service_Directory_User([
  'primaryEmail' => 'marty.mcfly@' . $CUSTOMER_DOMAIN,
  'password' => 'Timecircuit88',
  'name' => [
    'givenName' => 'Marty',
    'familyName' => 'McFly',
    'fullName' => 'Marty McFly'
  ]
]);
$response = $directoryService->users->insert($user);
print_r ($response);

// Promote user to admin status
$makeAdmin = new Google_Service_Directory_UserMakeAdmin([
  'status' => true
]);
$directoryService->users->makeAdmin(
  'marty.mcfly@' . $CUSTOMER_DOMAIN,
  $makeAdmin
);

// Create subscription resource
$subscription = new Google_Service_Reseller_Subscription([
  'customerId' => $CUSTOMER_DOMAIN,
  'skuId' => '1010020027',
  'plan' => [
    'planName' => 'ANNUAL_MONTHLY_PAY'
  ],
  'seats' => [
    'numberOfSeats' => '5'
  ],
  'renewalSettings' => [
    'renewalType' => 'RENEW_CURRENT_USERS_MONTHLY_PAY'
  ]
]);
$response = $resellerService->subscriptions->insert(
  $CUSTOMER_DOMAIN,
  $subscription
);
print_r ($response);

// Verify domain and designate domain owners
$body =
new Google_Service_SiteVerification_SiteVerificationWebResourceResource([
  'site' => [
    'type' => 'INET_DOMAIN',
    'identifier' => $CUSTOMER_DOMAIN,
  ],
  'owners' => ['marty.mcfly@' . $CUSTOMER_DOMAIN]
]);

$response = $verificationService->webResource->insert('DNS_TXT', $body);
print_r ($response);
Ruby
require 'googleauth'
require 'google/apis/reseller_v1'
require 'google/apis/site_verification_v1'
require 'google/apis/admin_directory_v1'

# Full List of scopes:
# https://developers.google.com/identity/protocols/googlescopes
OAUTH2_SCOPES = [
  'https://reseller.googleapis.com/auth/apps.order',
  'https://reseller.googleapis.com/auth/admin.directory.user',
  'https://reseller.googleapis.com/auth/siteverification',
]

####### REPLACE WITH YOUR OWN VALUES ###############
JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json'
RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com'
CUSTOMER_DOMAIN = 'example.com'
CUSTOMER_SITE = 'https://www.example.com/'
####################################################

credentials = Google::Auth::ServiceAccountCredentials.make_creds(
  json_key_io: File.open(JSON_PRIVATE_KEY_FILE),
  scope: OAUTH2_SCOPES)
credentials.sub = RESELLER_ADMIN_USER

Google::Apis::RequestOptions.default.authorization = credentials

reseller_service = Google::Apis::ResellerV1::ResellerService.new
directory_service = Google::Apis::AdminDirectoryV1::DirectoryService.new
verification_service = Google::Apis::SiteVerificationV1::SiteVerificationService.new

# Retrieve the site verification token and place it according to:
# https://developers.google.com/site-verification/v1/getting_started#tokens
request = Google::Apis::SiteVerificationV1::GetWebResourceTokenRequest.new(
  site: {
    type: 'INET_DOMAIN',
    identifier: CUSTOMER_DOMAIN
  },
  verification_method: 'DNS_TXT'
)

response = verification_service.get_web_resource_token(request)
puts response.inspect

# Determine if customer domain already has Google Workspace
begin
  reseller_service.get_customer(CUSTOMER_DOMAIN)
  abort('Customer already exists if call succeeds')
rescue Google::Apis::ClientError => ex
  if ex.status_code == 404
    puts 'Domain available for Google Workspace creation'
  else
    raise ex
  end
end

# Create customer resource
customer = Google::Apis::ResellerV1::Customer.new(
  customer_domain: CUSTOMER_DOMAIN,
  alternate_email: 'marty.mcfly@gmail.com',
  postal_address: {
    contact_name: 'Marty McFly',
    organization_name: 'Acme Corp',
    country_code: 'US',
    postal_code: '10009'})

response = reseller_service.insert_customer(customer)
puts response.inspect

# Create first admin user
user = Google::Apis::AdminDirectoryV1::User.new(
  name: {
    given_name: 'Marty',
    family_name: 'McFly',
    full_name: 'Marty McFly'
  },
  password: 'Timecircuit88',
  primary_email: 'marty.mcfly@' + CUSTOMER_DOMAIN,
)

response = directory_service.insert_user(user)
puts response.inspect

# Promote user to admin status
admin_status = Google::Apis::AdminDirectoryV1::UserMakeAdmin.new(
  status: true
)

response = directory_service.make_user_admin('marty.mcfly@' + CUSTOMER_DOMAIN, admin_status)

# Create subscription resource
subscription = Google::Apis::ResellerV1::Subscription.new(
  customer_id: CUSTOMER_DOMAIN,
  sku_id: '1010020027',
  plan: {
    plan_name: 'ANNUAL_MONTHLY_PAY'
  },
  seats: {
    number_of_seats: 5,
  },
  renewal_settings: {
    renewal_type: 'RENEW_CURRENT_USERS_MONTHLY_PAY'
  }
)

response = reseller_service.insert_subscription(CUSTOMER_DOMAIN, subscription)
puts response.inspect

# Verify domain and designate domain owners
webResource = Google::Apis::SiteVerificationV1::SiteVerificationWebResourceResource.new(
  site: {
    type: 'INET_DOMAIN',
    identifier: CUSTOMER_DOMAIN
  },
  owners: ['marty.mcfly@' + CUSTOMER_DOMAIN]
)

response = verification_service.insert_web_resource('DNS_TXT', webResource)
puts response.inspect
Node.js
// NOTE: This script needs googleapis 28.0.0 or later as it uses promises
const {google} = require('googleapis');

// ############## REPLACE WITH YOUR OWN VALUES ####################
const JSON_PRIVATE_KEY_FILE = 'path/to/json_key_file.json';
const RESELLER_ADMIN_USER = 'admin@yourresellerdomain.com';
const CUSTOMER_DOMAIN = 'example.com';
const CUSTOMER_SITE = 'https://www.example.com/';
// ################################################################

// Full List of scopes: https://developers.google.com/identity/protocols/googlescopes
const OAUTH2_SCOPES = [
  'https://reseller.googleapis.com/auth/apps.order',
  'https://reseller.googleapis.com/auth/siteverification',
  'https://reseller.googleapis.com/auth/admin.directory.user',
];

const authJWT = new google.auth.JWT({
  keyFile: JSON_PRIVATE_KEY_FILE,
  scopes: OAUTH2_SCOPES,
  subject: RESELLER_ADMIN_USER,
});

const resellerService = google.reseller({version: 'v1', auth: authJWT});
const directoryService = google.admin({version: 'directory_v1', auth: authJWT});
const verificationService = google.siteVerification({version: 'v1', auth: authJWT});

// Run all the steps one after each other, and exit as soon as one of them fail
Promise.resolve()
  .then(() => {
    /**
     * Retrieve the site verification token and place it according to:
     * https://developers.google.com/site-verification/v1/getting_started#tokens
     */
    const getTokenPromise = verificationService.webResource.getToken({
      requestBody: {
        site: {
          type: 'INET_DOMAIN',
          identifier: CUSTOMER_DOMAIN,
        },
        verificationMethod: 'DNS_TXT',
      }
    }).then(({data}) => {
      console.log(data);
      return data;
    });


    return getTokenPromise;
  })
  .then(() => {
    // Determine if customer domain already has Google Workspace
    const getCustomerPromise = resellerService.customers.get({
      customerId: CUSTOMER_DOMAIN
    }).then(() => {
      throw new Error('Customer already exists');
    }, resErr => {
      if (resErr.code === 404) {
        console.log('Domain available for Google Workspace creation');
      } else {
        throw resErr;
      }
    });

    return getCustomerPromise;
  })
  .then(() => {
    // Create customer resource
    const insertCustomerPromise = resellerService.customers.insert({
      requestBody: {
        customerDomain: CUSTOMER_DOMAIN,
        alternateEmail: 'marty.mcfly@gmail.com',
        postalAddress: {
          contactName: 'Marty McFly',
          organizationName: 'Acme Corp',
          postalCode: '10009',
          countryCode: 'US',
        }
      }
    }).then(({data}) => {
      console.log(data);
      return data;
    });

    return insertCustomerPromise;
  })
  .then(() => {
    // Create first admin user
    const insertUserPromise = directoryService.users.insert({
      requestBody: {
        primaryEmail: `marty.mcfly@${CUSTOMER_DOMAIN}`,
        name: {
          givenName: 'Marty',
          familyName: 'McFly',
        },
        password: 'Timecircuit88',
      }
    }).then(({data}) => {
      console.log(data);
      return data;
    });

    return insertUserPromise;
  }).then(() => {
    // Promote user to admin status
    const makeAdminPromise = directoryService.users.makeAdmin({
      userKey: `marty.mcfly@${CUSTOMER_DOMAIN}`,
      requestBody: {
        status: true
      }
    });

    return makeAdminPromise;
  })
  .then(() => {
    // Create subscription resource
    const insertSubscriptionPromise = resellerService.subscriptions.insert({
      customerId: CUSTOMER_DOMAIN,
      requestBody: {
        customerId: CUSTOMER_DOMAIN,
        skuId: '1010020027',
        plan: {
          planName: 'ANNUAL_MONTHLY_PAY',
        },
        seats: {
          numberOfSeats: 5,
        },
        renewalSettings: { // only relevant for annual plans
          renewalType: 'RENEW_CURRENT_USERS_MONTHLY_PAY',
        }
      }
    }).then(({data}) => {
      console.log(data);
      return data;
    });

    return insertSubscriptionPromise;
  })
  .then(() => {
    // Verify domain and designate domain owners
    const verifyDomainPromise = verificationService.webResource.insert({
      verificationMethod: 'DNS_TXT',
      requestBody: {
        site: {
          type: 'INET_DOMAIN',
          identifier: CUSTOMER_DOMAIN,
        },
        owners: [`marty.mcfly@${CUSTOMER_DOMAIN}`],
      }
    }).then(({data}) => {
      console.log(data);
      return data;
    });

    return verifyDomainPromise;
  })
  .catch(err => {
    console.error('Error:', err.message);
    if (err.code) {
      console.log('Error code:', err.code);
    }
    if (err.errors) {
      console.log('Details:', err.errors);
    }
  });