고객 프로비저닝

이 가이드에서는 리셀러 API.

고객을 제대로 프로비저닝하려면 여러 단계를 포괄하는 여러 단계를 거쳐야 합니다. 할 수 있습니다.

그림 1. Google Workspace 고객을 프로비저닝하는 대략적인 단계

를 통해 개인정보처리방침을 정의할 수 있습니다.

를 통해 개인정보처리방침을 정의할 수 있습니다.

위 다이어그램은 각 단계에서 클러스터를 프로비저닝하기 위해 어떤 API가 사용되는지 고객:

• Site Verification API를 사용하여 도메인 확인 토큰을 추가합니다.
• 리셀러 API를 사용하여 고객을 만듭니다.
• Directory API를 사용하여 첫 번째 사용자를 만들고 관리자로 지정합니다.
• 리셀러 API를 사용하여 구독을 만듭니다.
• Site Verification API를 사용하여 도메인을 확인합니다.

기본 요건

• Google 리셀러 도메인 인스턴스
• 완전히 체결된 Google Workspace 파트너 계약입니다.

• Google 계정
• Partner Sales Console에서 서비스 약관에 동의합니다.
• 다양한 언어의 클라이언트 라이브러리를 다운로드합니다.

환경 설정

이 튜토리얼을 완료하려면 환경을 설정하세요.

API 사용 설정

Google API를 사용하려면 먼저 Google Cloud 프로젝트에서 사용 설정해야 합니다. 단일 Google Cloud 프로젝트에서 하나 이상의 API를 사용 설정할 수 있습니다.

• Google Cloud 콘솔에서 reseller API, Site Verification API, Admin SDK API 입니다 .

  APIS 사용 설정

서비스 계정 만들기

서비스 계정은 애플리케이션이 아닌 더 클 수 있습니다. 서비스 계정을 사용하여 데이터에 액세스하거나 작업을 수행할 수 있습니다. Google Workspace를 대신하여 데이터에 액세스하는 행위 액세스할 수 있습니다 자세한 내용은 서비스 계정 이해를 참조하세요.

Google Cloud 콘솔

1. Google Cloud 콘솔에서 메뉴 로 이동합니다. > IAM 및 관리자 > 서비스 계정으로 이동합니다.

   서비스 계정으로 이동

2. 서비스 계정 만들기를 클릭합니다.
3. 서비스 계정 세부정보를 입력한 다음 만들고 계속하기를 클릭합니다.
   참고: 기본적으로 Google에서는 고유한 서비스 계정 ID를 생성합니다. 원하는 경우 ID를 변경하려면 서비스 계정 ID 필드에서 ID를 수정하세요.
4. 선택사항: 서비스 계정에 역할을 할당하여 Google Cloud 프로젝트의 리소스에 대한 액세스 권한을 부여합니다. 자세한 내용은 리소스에 대한 액세스 권한 부여, 변경, 취소를 참조하세요.
5. 계속을 클릭합니다.
6. 선택사항: 이 서비스 계정으로 관리하고 작업을 수행할 수 있는 사용자 또는 그룹을 입력합니다. 자세한 내용은 서비스 계정 가장 기능 관리를 참고하세요.
7. 완료를 클릭합니다. 서비스 계정의 이메일 주소를 기록해 둡니다.

gcloud CLI

1. 서비스 계정을 만듭니다.

   gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
     --display-name="SERVICE_ACCOUNT_NAME"

2. 선택사항: 서비스 계정에 역할을 할당하여 Google Cloud 프로젝트의 리소스에 대한 액세스 권한을 부여합니다. 자세한 내용은 리소스에 대한 액세스 권한 부여, 변경, 취소를 참조하세요.

서비스 계정의 사용자 인증 정보 만들기

공개 키/비공개 키 쌍 형식의 사용자 인증 정보를 얻어야 합니다. 이러한 사용자 인증 정보는 코드에서 서비스 계정 작업을 승인하는 데 사용됩니다. 있습니다. <ph type="x-smartling-placeholder">

</ph>
1. Google Cloud 콘솔에서 메뉴 로 이동합니다. &gt; IAM 및 관리자 &gt; 서비스 계정으로 이동합니다.

   서비스 계정으로 이동

2. 서비스 계정을 선택합니다.
3. 키 &gt; 키 추가 &gt; 새 키 만들기를 클릭합니다.
4. JSON을 선택한 다음 만들기를 클릭합니다.

   새 공개/비공개 키 쌍이 생성되어 머신을 새 파일로 저장합니다. 다운로드한 JSON 파일을 credentials.json로 작업 디렉터리에 있습니다 이 파일은 이 키의 유일한 사본입니다. 스토리지, 앱, 이미지, 데이터 및 안전하게 보관하려면 서비스 계정 키 관리.

5. 닫기를 클릭합니다.

서비스 계정에 도메인 전체 위임 설정

Google Workspace 조직의 사용자를 대신하여 API를 호출하려면 다음 안내를 따르세요. 서비스 계정에 Google Workspace 관리 콘솔에 액세스할 수 없습니다. 자세한 내용은 자세한 내용은 서비스 계정에 도메인 전체 권한 위임.

1. Google Cloud 콘솔에서 메뉴 로 이동합니다. &gt; IAM 및 관리자 &gt; 서비스 계정으로 이동합니다.

   서비스 계정으로 이동

2. 서비스 계정을 선택합니다.
3. 고급 설정 표시를 클릭합니다.
4. '도메인 전체 위임' 아래에서 서비스 계정의 '클라이언트 ID'를 찾습니다 복사 를 클릭하여 클라이언트 ID 값을 클립보드에 복사합니다.

5. 관련 Google Workspace 계정에 대한 최고 관리자 액세스 권한이 있는 경우 Google Workspace 관리 콘솔을 확인한 후 최고 관리자를 사용하여 로그인합니다. 계정에 로그인하고 다음 단계를 계속 진행합니다.

   관련 Google Workspace 계정에 대한 최고 관리자 액세스 권한이 없는 경우 해당 계정의 최고 관리자에게 문의하여 서비스 계정의 클라이언트 ID 전송 및 OAuth 범위 목록을 표시하여 관리 콘솔에서 다음 단계를 완료할 수 있도록 합니다.

1. Google 관리 콘솔에서 메뉴 로 이동합니다. &gt; 보안 &gt; 액세스 및 데이터 관리 &gt; API 관리로 이동합니다.

   API 컨트롤로 이동

2. 도메인 전체 위임 관리를 클릭합니다.
3. 새로 추가를 클릭합니다.
4. '클라이언트 ID' 입력란에 이전에 복사한 클라이언트 ID를 붙여넣습니다.
5. 'OAuth 범위'에서 필드에 애플리케이션에 필요한 범위를 쉼표로 구분된 목록으로 입력합니다. OAuth 동의 화면을 구성할 때 정의한 것과 동일한 범위입니다.
6. 승인을 클릭합니다.

인증된 사용자 인증 정보로 서비스 객체 만들기

Google API를 시작하려면 먼저 인증을 설정해야 합니다. 사용자 인증 정보를 가져올 수 있습니다 Google 클라이언트 라이브러리 자동으로 처리합니다 모든 라이브러리에는 인코더-디코더 아키텍처를 생성하기 위한 사용자 인증 정보 객체를 제공합니다. 이 객체는 모든 API에 대한 액세스 권한을 부여하고 연결할 수 있습니다 애플리케이션에는 일반적으로 애플리케이션의 모든 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 = '[e-mail]'
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)

자바

// 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 = "[e-mail]";
  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 = "[e-mail]";
    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 = '[e-mail]';
$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 = '[e-mail]'
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 = '[e-mail]';
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});

도메인 확인 절차 시작

이 단계는 선택사항이지만 않습니다. 이 단계는 도메인을 확인합니다

고객의 도메인을 확인하지 않는 경우 고객은 다음을 보유하게 됩니다. 제한:

• 사용자는 관리 콘솔에만 액세스할 수 있으며 수동 도메인 확인 프로세스를 사용합니다.
• 생성 후 21일이 지나면 정지될 수 있습니다.

사이트 인증 토큰을 검색하려면 다음 단계를 따르세요.

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)

     자바

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

     다음 토큰 검색 예시에서는 SITE 유형을 FILE와 함께 사용합니다. 확인 방법을 사용합니다. 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)

     자바

     // 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. DNS 레코드 또는 사이트에 사이트 인증 토큰을 배치합니다.

리셀러 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

   자바

   // 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은(는) 2자리 ISO 국가여야 합니다. 있습니다.

   다음 예는 고객 레코드 생성을 보여줍니다.

   Python

   # Create customer resource
   response = reseller_service.customers().insert(
       body={
           'customerDomain': CUSTOMER_DOMAIN,
           'alternateEmail': '[e-mail]',
           'postalAddress': {
               'contactName': 'Marty McFly',
               'organizationName': 'Acme Corp',
               'postalCode': '10009',
               'countryCode': 'US',
           }
       }).execute()
   print(response)

   자바

   // 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("[e-mail]")
     .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 = "[e-mail]",
       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' => '[e-mail]',
     '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: '[e-mail]',
     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: '[e-mail]',
       postalAddress: {
         contactName: 'Marty McFly',
         organizationName: 'Acme Corp',
         postalCode: '10009',
         countryCode: 'US',
       }
     }
   }).then(({data}) => {
     console.log(data);
     return data;
   });

Admin SDK API로 첫 번째 관리자 만들기

고객을 프로비저닝한 후 첫 번째 사용자를 만들고 즉시 만들어야 합니다. 고객이 다음을 수행할 수 있도록 사용자를 도메인 최고 관리자로 업그레이드합니다. 새 서비스에 액세스하고 관련 서비스 약관에 동의합니다.

1. 첫 번째 사용자를 만들고 비밀번호를 설정합니다. 비밀번호가 적절해야 합니다. 최소 8자 이상을 포함해야 합니다 자세한 내용은 자세한 내용은 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)

   자바

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

   자바

   // 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 필드에 이 고객의 거래 ID 또는 ID를 입력합니다. 특정 인수와 값에 대한 자세한 내용은 다음을 참조하세요. 정기 결제 관리

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)

   자바

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

자바

// 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() 호출 확인되었습니다.

종합해보기

다음 예는 단일 IP 주소를 사용하여 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 = '[e-mail]'
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': '[e-mail]',
        '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)

자바

// 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 = "[e-mail]";
  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("[e-mail]")
      .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 = "[e-mail]";
    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 = "[e-mail]",
            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 = '[e-mail]';
$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' => '[e-mail]',
  '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 = '[e-mail]'
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: '[e-mail]',
  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 = '[e-mail]';
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: '[e-mail]',
        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);
    }
  });