채용정보 기본사항

채용정보 리소스는 채용 공고를 나타냅니다. 채용 공고를 '구인 공고' 또는 '구인 요청'이라고도 합니다. 채용정보는 채용을 진행하는 고용 주체를 대표하는 회사의 리소스입니다.

LIST 및 GET 메서드를 사용하여 채용정보에 액세스하고 CREATE, UPDATE, DELETE 메서드를 사용하여 조작할 수 있습니다. Cloud Talent Solution 색인이 변경사항을 반영하는 데 몇 분이 걸릴 수 있습니다.

채용정보는 서비스 계정 범위에 포함됩니다. 특정 서비스 계정의 사용자 인증 정보를 사용하여 인증된 검색 요청을 통해서만 이러한 채용정보 콘텐츠에 액세스할 수 있습니다.

문제를 간편하게 선별하고 해결하도록 Cloud Talent Solution의 채용정보 색인을 자체 채용정보 색인과 동기화하고 Cloud Talent Solution에서 생성된 name과 시스템의 고유한 채용정보 식별자 간의 관계를 유지합니다. 채용정보가 변경되거나 시스템에 등록될 때 이러한 변경사항이 즉시 반영되도록 실시간으로 적절한 CRUD 호출을 CTS에 전송해야 합니다. 기존의 채용정보 데이터 수집 파이프라인에 CTS 색인을 추가해야 합니다.

작업 만들기

아래 코드 샘플을 사용하여 채용정보를 생성할 수 있습니다. 자세한 내용은 빠른 시작: 회사 및 채용정보 만들기를 참조하십시오. 동영상 가이드 및 대화형 Codelab도 사용 가능합니다.

Go

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// createJob create a job as given.
func createJob(w io.Writer, projectID, companyID, requisitionID, title, URI, description, address1, address2, languageCode string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	jobToCreate := &talentpb.Job{
		CompanyName:   fmt.Sprintf("projects/%s/companies/%s", projectID, companyID),
		RequisitionId: requisitionID,
		Title:         title,
		ApplicationInfo: &talentpb.Job_ApplicationInfo{
			Uris: []string{URI},
		},
		Description:  description,
		Addresses:    []string{address1, address2},
		LanguageCode: languageCode,
	}

	// Construct a createJob request.
	req := &talentpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Job:    jobToCreate,
	}

	resp, err := c.CreateJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to create job: %v\n", err)
		return nil, err
	}

	fmt.Printf("Created job: %q\n", resp.GetName())

	return resp, nil
}

자바

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


import com.google.cloud.talent.v4.CreateJobRequest;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.TenantName;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;

public class JobSearchCreateJob {

  public static void createJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String companyId = "your-company-id";
    String requisitionId = "your-unique-req-id";
    String jobApplicationUrl = "your-job-url";
    // String projectId = "me-qa-1";
    // String tenantId = "8ed97629-27ee-4215-909b-18cfe3b7e8e3";
    // String companyId = "05317758-b30e-4b26-a57d-d9e54e4cccd8";
    // String requisitionId = "test-requisitionid-1";
    // String jobApplicationUrl = "http://job.url";
    createJob(projectId, tenantId, companyId, requisitionId, jobApplicationUrl);
  }

  // Create a job.
  public static void createJob(
      String projectId,
      String tenantId,
      String companyId,
      String requisitionId,
      String jobApplicationUrl)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      TenantName parent = TenantName.of(projectId, tenantId);
      Job.ApplicationInfo applicationInfo =
          Job.ApplicationInfo.newBuilder().addUris(jobApplicationUrl).build();

      List<String> addresses =
          Arrays.asList(
              "1600 Amphitheatre Parkway, Mountain View, CA 94043",
              "111 8th Avenue, New York, NY 10011");

      // By default, job will expire in 30 days.
      // https://cloud.google.com/talent-solution/job-search/docs/jobs
      Job job =
          Job.newBuilder()
              .setCompany(companyId)
              .setRequisitionId(requisitionId)
              .setTitle("Software Developer")
              .setDescription("Develop, maintain the software solutions.")
              .setApplicationInfo(applicationInfo)
              .addAllAddresses(addresses)
              .setLanguageCode("en-US")
              .build();

      CreateJobRequest request =
          CreateJobRequest.newBuilder().setParent(parent.toString()).setJob(job).build();

      Job response = jobServiceClient.createJob(request);
      System.out.format("Created job: %s%n", response.getName());
    }
  }
}

Node.js

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


const talent = require('@google-cloud/talent').v4;

/**
 * Create Job
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenant
 */
function sampleCreateJob(
  projectId,
  tenantId,
  companyName,
  requisitionId,
  title,
  description,
  jobApplicationUrl,
  addressOne,
  addressTwo,
  languageCode
) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const companyName = 'Company name, e.g. projects/your-project/companies/company-id';
  // const requisitionId = 'Job requisition ID, aka Posting ID. Unique per job.';
  // const title = 'Software Engineer';
  // const description = 'This is a description of this <i>wonderful</i> job!';
  // const jobApplicationUrl = 'https://www.example.org/job-posting/123';
  // const addressOne = '1600 Amphitheatre Parkway, Mountain View, CA 94043';
  // const addressTwo = '111 8th Avenue, New York, NY 10011';
  // const languageCode = 'en-US';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const uris = [jobApplicationUrl];
  const applicationInfo = {
    uris: uris,
  };
  const addresses = [addressOne, addressTwo];
  const job = {
    company: companyName,
    requisitionId: requisitionId,
    title: title,
    description: description,
    applicationInfo: applicationInfo,
    addresses: addresses,
    languageCode: languageCode,
  };
  const request = {
    parent: formattedParent,
    job: job,
  };
  client
    .createJob(request)
    .then(responses => {
      const response = responses[0];
      console.log(`Created job: ${response.name}`);
    })
    .catch(err => {
      console.error(err);
    });
}

Python

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


from google.cloud import talent
import six

def create_job(
    project_id, tenant_id, company_id, requisition_id, job_application_url,
):
    """Create Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # company_id = 'Company name, e.g. projects/your-project/companies/company-id'
    # requisition_id = 'Job requisition ID, aka Posting ID. Unique per job.'
    # title = 'Software Engineer'
    # description = 'This is a description of this <i>wonderful</i> job!'
    # job_application_url = 'https://www.example.org/job-posting/123'
    # address_one = '1600 Amphitheatre Parkway, Mountain View, CA 94043'
    # address_two = '111 8th Avenue, New York, NY 10011'
    # language_code = 'en-US'

    if isinstance(project_id, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(company_id, six.binary_type):
        company_id = company_id.decode("utf-8")
    if isinstance(requisition_id, six.binary_type):
        requisition_id = requisition_id.decode("utf-8")
    if isinstance(job_application_url, six.binary_type):
        job_application_url = job_application_url.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"
    uris = [job_application_url]
    application_info = {"uris": uris}
    addresses = [
        "1600 Amphitheatre Parkway, Mountain View, CA 94043",
        "111 8th Avenue, New York, NY 10011",
    ]
    job = {
        "company": company_id,
        "requisition_id": requisition_id,
        "title": "Software Developer",
        "description": "Develop, maintain the software solutions.",
        "application_info": application_info,
        "addresses": addresses,
        "language_code": "en-US",
    }

    response = client.create_job(parent=parent, job=job)
    print("Created job: {}".format(response.name))
    return response.name

Ruby

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

require "google/cloud/talent"

# Instantiate a client
job_service = Google::Cloud::Talent.job_service

# project_id = "Your Google Cloud Project ID"
# tenant_id = "Your Tenant ID (using tenancy is required)"
parent = job_service.tenant_path project: project_id, tenant: tenant_id

# job_application_url = "https://www.example.org/job-posting/123"
uris = [job_application_url]
application_info = { uris: uris }

# address = "1600 Amphitheatre Parkway, Mountain View, CA 94043"
addresses = [address]

# company_name = "Company name, e.g. projects/your-project/companies/company-id"
# requisition_id = "Job requisition ID, aka Posting ID. Unique per job."
# title = "Software Engineer"
# description = "This is a description of this <i>wonderful</i> job!"
# language_code = "en-US"
job = {
  company:          company_name,
  requisition_id:   requisition_id,
  title:            title,
  description:      description,
  application_info: application_info,
  addresses:        addresses,
  language_code:    language_code
}

response = job_service.create_job parent: parent, job: job
puts "Created job: #{response.name}"

C#

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

public static object CreateJob(string projectId, string tenantId, string companyId, string requisitionId, string jobApplicationUrl)
{
    JobServiceClient jobServiceClient = JobServiceClient.Create();
    TenantName tenantName = TenantName.FromProjectTenant(projectId, tenantId);

    ApplicationInfo applicationInfo = new ApplicationInfo();
    applicationInfo.Uris.Add(jobApplicationUrl);

    Job job = new Job
    {
        Company = companyId,
        RequisitionId = requisitionId,
        Title = "Software Developer",
        Description = "Develop, maintain the software solutions.",
        ApplicationInfo = applicationInfo,
        LanguageCode = "en-US"
    };
    string[] addresses = { "1600 Amphitheatre Parkway, Mountain View, CA 94043", "111 8th Avenue, New York, NY 10011" };
    job.Addresses.Add(addresses);

    CreateJobRequest request = new CreateJobRequest
    {
        ParentAsTenantName = tenantName,
        Job = job
    };

    Job response = jobServiceClient.CreateJob(request);

    Console.WriteLine($"Created Job: {response.Name}");
    return 0;
}

필수 필드

채용정보를 만들고 업데이트할 때의 필수 필드는 다음과 같습니다.

  • companyName: 채용정보를 소유한 회사의 리소스 이름(예: companyName=\"projects/{ProjectId}/companies/{CompanyId}\")

  • requisitionId: 요청 ID(게시 ID라고도 함)는 작업을 식별하기 위해 지정하는 값입니다. 이 필드는 고객 식별 및 요청 추적에 사용할 수 있습니다. 허용되는 최대 문자 수는 225자(영문 기준)입니다.

    채용 공고의 고유성은 requisitionID, companyName, 위치의 조합을 사용하여 결정됩니다. 이러한 속성의 특정 키를 사용하여 채용정보를 만든 경우, 이 키는 Cloud Talent Solution 색인에 저장되며 채용정보가 삭제되기 전까지는 동일한 필드가 있는 다른 채용정보를 만들 수 없습니다.

  • title: 직책(예: '소프트웨어 엔지니어') 허용되는 최대 문자 수는 500자(영문 기준)입니다.

    Cloud Talent Solution은 일반적이지 않은 직책으로 인해 검색결과가 누락되는 문제를 해결하기 위해 모든 채용정보 필드를 활용하여 채용정보의 컨텍스트를 파악하고 채용정보의 '정리된' 직책을 내부적으로 저장합니다. 검색 요청이 서비스로 전송될 때 검색어도 정리되며, 정리된 쿼리를 정리된 관련 채용정보에 매핑하는 데 온톨로지가 사용됩니다.

  • description: 채용정보에 대한 설명으로, 여기에는 일반적으로 여러 단락으로 구성된 회사 및 관련 정보가 포함됩니다. 직무, 자격 요건, 기타 업무 특성을 취급하는 별도의 필드가 채용정보 객체에 제공됩니다. 이러한 별도의 필드를 사용하는 것이 좋습니다.

    이 필드는 HTML 입력을 허용 및 정리하며 굵게, 기울임꼴, 순서가 지정된 목록, 순서가 지정되지 않은 목록의 마크업 태그를 허용합니다. 허용되는 최대 문자 수는 100,000자(영문 기준)입니다.

다음 필드 중 하나는 사용해야 합니다.

  • applicationInfo.uris: 지원 페이지의 URL입니다.

  • applicationInfo.emails: 이력서 또는 지원서를 보낼 이메일 주소입니다.

  • applicationInfo.instruction: '지원서 접수 주소' 등의 지원 안내입니다. 이 필드는 HTML 입력을 허용 및 정리하며 굵게, 기울임꼴, 순서가 지정된 목록, 순서가 지정되지 않은 목록의 마크업 태그를 허용합니다. 허용되는 최대 문자 수는 3,000자(영문 기준)입니다.

흔히 사용되는 필드

  • postingExpireTime: 타임스탬프 기준으로 채용 공고가 만료되는 시점입니다. 이 시간이 지나면 채용정보는 만료 상태로 표시되고 검색결과에 나타나지 않습니다. UTC 시간대로 2100년 12월 31일 이전으로만 설정할 수 있습니다. 잘못된 날짜(예: 지나간 날짜)는 무시됩니다. 채용정보가 만료되는 기본 날짜는 UTC 시간대 기준으로 채용정보 생성 시간으로부터 30일 후입니다.

    채용정보가 만료된 후 60일까지는 GET 연산자를 사용하여 만료된 채용정보 콘텐츠를 검색할 수 있습니다. 60일이 지나면 만료된 채용정보는 GET 연산자를 통해 반환되지 않습니다.

  • addresses: 채용정보 위치 통근 시간별 검색을 포함하여 채용정보 검색 결과를 개선하려면 채용 위치의 상세 주소를 제공하는 것이 좋습니다. 허용되는 최대 문자 수는 500자(영문 기준)입니다. addresses에 대한 자세한 내용은 아래 권장사항 섹션을 참조하세요.

  • promotionValue: 값이 0보다 크면 채용정보가 '추천 채용정보'로 정의되어 FEATURED_JOBS 유형의 검색에서만 반환됩니다. 값이 클수록 추천 검색결과에서 우선적으로 반환됩니다. 자세한 내용은 추천 채용정보를 참조하세요.

커스텀 채용정보 필드 사용

Cloud Talent Solution에는 API 스키마에 내장된 여러 채용정보 필드가 포함되어 있습니다. 그러나 기본 옵션에는 없는 추가 필드가 필요할 수 있습니다. 가능하면 기본 필드를 사용하는 것이 좋지만 Cloud Talent Solution은 채용정보에 일부 customAttributes 필드도 제공합니다. 이러한 속성은 필터링이 가능할 수도, 불가능할 수도 있습니다. 자세한 내용은 customAttributes 문서를 참조하세요.

  • customAttributes: 이 필드는 채용정보의 커스텀 데이터를 저장할 수 있는 커스텀 속성을 최대 100개까지 저장합니다. jobQuery 필드를 지정하면 이 필드를 검색 요청 기준으로 필터링할 수 있습니다. 또한 companykeywordSearchableJobCustomAttributes 속성에 이 필드를 설정하면 keywordSearchableJobCustomAttributes의 필드 중에서 검색어와 정확하게 일치하는 필드가 하나라도 있는 채용정보가 모두 반환됩니다.

다음 코드 예시는 customAttribute로 채용정보를 만드는 방법을 보여줍니다.

Go

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"github.com/gofrs/uuid"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
	money "google.golang.org/genproto/googleapis/type/money"
)

// createJobWithCustomAttributes creates a job with custom attributes.
func createJobWithCustomAttributes(w io.Writer, projectID, companyID, jobTitle string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a job service client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("talent.NewJobClient: %v", err)
	}

	// requisitionID shoud be the unique ID in your system
	requisitionID := fmt.Sprintf("job-with-custom-attribute-%s", uuid.Must(uuid.NewV4()).String())
	jobToCreate := &talentpb.Job{
		Company:       fmt.Sprintf("projects/%s/companies/%s", projectID, companyID),
		RequisitionId: requisitionID,
		Title:         jobTitle,
		ApplicationInfo: &talentpb.Job_ApplicationInfo{
			Uris: []string{"https://googlesample.com/career"},
		},
		Description:     "Design, devolop, test, deploy, maintain and improve software.",
		LanguageCode:    "en-US",
		PromotionValue:  2,
		EmploymentTypes: []talentpb.EmploymentType{talentpb.EmploymentType_FULL_TIME},
		Addresses:       []string{"Mountain View, CA"},
		CustomAttributes: map[string]*talentpb.CustomAttribute{
			"someFieldString": {
				Filterable:   true,
				StringValues: []string{"someStrVal"},
			},
			"someFieldLong": {
				Filterable: true,
				LongValues: []int64{900},
			},
		},
		CompensationInfo: &talentpb.CompensationInfo{
			Entries: []*talentpb.CompensationInfo_CompensationEntry{
				{
					Type: talentpb.CompensationInfo_BASE,
					Unit: talentpb.CompensationInfo_HOURLY,
					CompensationAmount: &talentpb.CompensationInfo_CompensationEntry_Amount{
						Amount: &money.Money{
							CurrencyCode: "USD",
							Units:        1,
						},
					},
				},
			},
		},
	}

	// Construct a createJob request.
	req := &talentpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		Job:    jobToCreate,
	}

	resp, err := c.CreateJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("CreateJob: %v", err)
	}

	fmt.Fprintf(w, "Created job with custom attributres: %q\n", resp.GetName())
	fmt.Fprintf(w, "Custom long field has value: %v\n", resp.GetCustomAttributes()["someFieldLong"].GetLongValues())

	return resp, nil
}

자바

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


import com.google.cloud.talent.v4.CreateJobRequest;
import com.google.cloud.talent.v4.CustomAttribute;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.TenantName;
import java.io.IOException;

public class JobSearchCreateJobCustomAttributes {

  public static void createJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String companyId = "your-company-id";
    String requisitionId = "your-unique-req-id";
    createJob(projectId, tenantId, companyId, requisitionId);
  }

  // Create Job with Custom Attributes.
  public static void createJob(
          String projectId,
          String tenantId,
          String companyId,
          String requisitionId)
          throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      TenantName parent = TenantName.of(projectId, tenantId);

      // Custom attribute can be string or numeric value, and can be filtered in search queries.
      // https://cloud.google.com/talent-solution/job-search/docs/custom-attributes
      CustomAttribute customAttribute = CustomAttribute.newBuilder()
              .addStringValues("Internship")
              .addStringValues("Apprenticeship")
              .setFilterable(true)
              .build();

      Job job =
              Job.newBuilder()
                      .setCompany(companyId)
                      .setTitle("Software Developer I")
                      .setDescription("This is a description of this <i>wonderful</i> job!")
                      .putCustomAttributes("FOR_STUDENTS", customAttribute)
                      .setRequisitionId(requisitionId)
                      .setLanguageCode("en-US")
                      .build();

      CreateJobRequest request =
              CreateJobRequest.newBuilder().setParent(parent.toString()).setJob(job).build();
      Job response = jobServiceClient.createJob(request);
      System.out.printf("Created job: %s\n", response.getName());
    }
  }
}

Node.js

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


const talent = require('@google-cloud/talent').v4;

/**
 * Create Job with Custom Attributes
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenantd
 */
function sampleCreateJob(
  projectId,
  tenantId,
  companyName,
  requisitionId,
  languageCode
) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const companyName = 'Company name, e.g. projects/your-project/companies/company-id';
  // const requisitionId = 'Job requisition ID, aka Posting ID. Unique per job.';
  // const languageCode = 'en-US';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const job = {
    company: companyName,
    requisitionId: requisitionId,
    languageCode: languageCode,
  };
  const request = {
    parent: formattedParent,
    job: job,
  };
  client
    .createJob(request)
    .then(responses => {
      const response = responses[0];
      console.log(`Created job: ${response.name}`);
    })
    .catch(err => {
      console.error(err);
    });
}

Python

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


from google.cloud import talent
import six

def create_job(project_id, tenant_id, company_id, requisition_id):
    """Create Job with Custom Attributes"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # company_id = 'Company name, e.g. projects/your-project/companies/company-id'
    # requisition_id = 'Job requisition ID, aka Posting ID. Unique per job.'
    # language_code = 'en-US'

    if isinstance(project_id, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(company_id, six.binary_type):
        company_id = company_id.decode("utf-8")

    # Custom attribute can be string or numeric value,
    # and can be filtered in search queries.
    # https://cloud.google.com/talent-solution/job-search/docs/custom-attributes
    custom_attribute = talent.CustomAttribute()
    custom_attribute.filterable = True
    custom_attribute.string_values.append("Intern")
    custom_attribute.string_values.append("Apprenticeship")

    parent = f"projects/{project_id}/tenants/{tenant_id}"

    job = talent.Job(
        company=company_id,
        title="Software Engineer",
        requisition_id=requisition_id,
        description="This is a description of this job",
        language_code="en-us",
        custom_attributes={"FOR_STUDENTS": custom_attribute}
    )

    response = client.create_job(parent=parent, job=job)
    print(f"Created job: {response.name}")
    return response.name

Ruby

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

require "google/cloud/talent"

# Instantiate a client
job_service = Google::Cloud::Talent.job_service

# project_id = "Your Google Cloud Project ID"
# tenant_id = "Your Tenant ID (using tenancy is required)"
parent = job_service.tenant_path project: project_id, tenant: tenant_id

# title = "Software Engineer"
# description = "This is a description of this <i>wonderful</i> job!"
# company_name = "Company name, e.g. projects/your-project/companies/company-id"
# requisition_id = "Job requisition ID, aka Posting ID. Unique per job."
# language_code = "en-US"
job = {
  title:          title,
  description:    description,
  company:        company_name,
  requisition_id: requisition_id,
  language_code:  language_code
}

response = job_service.create_job parent: parent, job: job
puts "Created job: #{response.name}"

C#

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

public static object CreateJobCustomAttributes(string projectId, string tenantId, string companyId, string requisitionId)
{
    JobServiceClient jobServiceClient = JobServiceClient.Create();
    TenantName tenantName = TenantName.FromProjectTenant(projectId, tenantId);

    // Custom attribute can be string or numeric value, and can be filtered in search queries.
    // https://cloud.google.com/talent-solution/job-search/docs/custom-attributes
    CustomAttribute customAttributes = new CustomAttribute
    {
        Filterable = true
    };
    customAttributes.StringValues.Add("Internship");
    customAttributes.StringValues.Add("Intern");
    customAttributes.StringValues.Add("Apprenticeship");

    Job job = new Job
    {
        Company = companyId,
        RequisitionId = requisitionId,
        Title = "Software Developer I",
        Description = "This is a description of this <i>wonderful</i> job!",
        LanguageCode = "en-US"
    };
    job.CustomAttributes.Add("FOR_STUDENTS", customAttributes);

    CreateJobRequest request = new CreateJobRequest
    {
        ParentAsTenantName = tenantName,
        Job = job
    };

    Job response = jobServiceClient.CreateJob(request);

    Console.WriteLine($"Created Job: {response.Name}");
    return 0;
}

채용정보 검색

Go

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// getJob gets an existing job by its resource name.
func getJob(w io.Writer, projectID, jobID string) (*talentpb.Job, error) {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return nil, err
	}

	// Construct a getJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.GetJobRequest{
		// The resource name of the job to retrieve.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	resp, err := c.GetJob(ctx, req)
	if err != nil {
		fmt.Printf("Failed to get job %s: %v\n", jobName, err)
		return nil, err
	}

	fmt.Fprintf(w, "Job: %q\n", resp.GetName())
	fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())

	return resp, err
}

자바

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


import com.google.cloud.talent.v4.GetJobRequest;
import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobName;
import com.google.cloud.talent.v4.JobServiceClient;
import java.io.IOException;

public class JobSearchGetJob {

  public static void getJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    getJob(projectId, tenantId, jobId);
  }

  // Get Job.
  public static void getJob(String projectId, String tenantId, String jobId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      JobName name = JobName.of(projectId, tenantId, jobId);

      GetJobRequest request = GetJobRequest.newBuilder().setName(name.toString()).build();

      Job response = jobServiceClient.getJob(request);
      System.out.format("Job name: %s%n", response.getName());
      System.out.format("Requisition ID: %s%n", response.getRequisitionId());
      System.out.format("Title: %s%n", response.getTitle());
      System.out.format("Description: %s%n", response.getDescription());
      System.out.format("Posting language: %s%n", response.getLanguageCode());
      for (String address : response.getAddressesList()) {
        System.out.format("Address: %s%n", address);
      }
      for (String email : response.getApplicationInfo().getEmailsList()) {
        System.out.format("Email: %s%n", email);
      }
      for (String websiteUri : response.getApplicationInfo().getUrisList()) {
        System.out.format("Website: %s%n", websiteUri);
      }
    }
  }
}

Node.js

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


const talent = require('@google-cloud/talent').v4;

/** Get Job */
function sampleGetJob(projectId, tenantId, jobId) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const jobId = 'Job ID';
  const formattedName = client.jobPath(projectId, tenantId, jobId);
  client
    .getJob({name: formattedName})
    .then(responses => {
      const response = responses[0];
      console.log(`Job name: ${response.name}`);
      console.log(`Requisition ID: ${response.requisitionId}`);
      console.log(`Title: ${response.title}`);
      console.log(`Description: ${response.description}`);
      console.log(`Posting language: ${response.languageCode}`);
      for (const address of response.addresses) {
        console.log(`Address: ${address}`);
      }
      for (const email of response.applicationInfo.emails) {
        console.log(`Email: ${email}`);
      }
      for (const websiteUri of response.applicationInfo.uris) {
        console.log(`Website: ${websiteUri}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


from google.cloud import talent
import six

def get_job(project_id, tenant_id, job_id):
    """Get Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Job ID'

    if isinstance(project_id, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(job_id, six.binary_type):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    response = client.get_job(name=name)
    print(f"Job name: {response.name}")
    print(f"Requisition ID: {response.requisition_id}")
    print(f"Title: {response.title}")
    print(f"Description: {response.description}")
    print(f"Posting language: {response.language_code}")
    for address in response.addresses:
        print(f"Address: {address}")
    for email in response.application_info.emails:
        print(f"Email: {email}")
    for website_uri in response.application_info.uris:
        print(f"Website: {website_uri}")

Ruby

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

require "google/cloud/talent"

# Instantiate a client
job_service = Google::Cloud::Talent.job_service

# project_id = "Your Google Cloud Project ID"
# tenant_id = "Your Tenant ID (using tenancy is required)"
# job_id = "Job ID"
formatted_name = job_service.job_path project: project_id,
                                      tenant:  tenant_id,
                                      job:     job_id

response = job_service.get_job name: formatted_name
puts "Job name: #{response.name}"
puts "Requisition ID: #{response.requisition_id}"
puts "Title: #{response.title}"
puts "Description: #{response.description}"
puts "Posting language: #{response.language_code}"
response.addresses.each do |address|
  puts "Address: #{address}"
end
response.application_info.emails.each do |email|
  puts "Email: #{email}"
end
response.application_info.uris.each do |website_uri|
  puts "Website: #{website_uri}"
end

C#

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

public static object GetJob(string projectId, string tenantId, string jobId)
{
    JobServiceClient jobServiceClient = JobServiceClient.Create();
    JobName jobName = JobName.FromProjectTenantJob(projectId, tenantId, jobId);
    GetJobRequest request = new GetJobRequest
    {
        JobName = jobName
    };
    var response = jobServiceClient.GetJob(request);

    Console.WriteLine($"Job name: {response.Name}");
    Console.WriteLine($"Requisition ID: {response.RequisitionId}");
    Console.WriteLine($"Title: {response.Title}");
    Console.WriteLine($"Description: {response.Description}");
    Console.WriteLine($"Posting language: {response.LanguageCode}");
    foreach (string address in response.Addresses)
    {
        Console.WriteLine($"Address: {address}");
    }
    foreach (string email in response.ApplicationInfo.Emails)
    {
        Console.WriteLine($"Email: {email}");
    }
    foreach (string websiteUri in response.ApplicationInfo.Uris)
    {
        Console.WriteLine($"Website: {websiteUri}");
    }
    return 0;
}

작업 표시

Go

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	"google.golang.org/api/iterator"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// listJobs lists jobs with a filter, for example
// `companyName="projects/my-project/companies/123"`.
func listJobs(w io.Writer, projectID, companyID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a listJobs request.
	companyName := fmt.Sprintf("projects/%s/companies/%s", projectID, companyID)
	req := &talentpb.ListJobsRequest{
		Parent: "projects/" + projectID,
		Filter: fmt.Sprintf("companyName=%q", companyName),
	}

	it := c.ListJobs(ctx, req)

	for {
		resp, err := it.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			fmt.Printf("it.Next: %v\n", err)
			return err
		}
		fmt.Fprintf(w, "Listing job: %v\n", resp.GetName())
		fmt.Fprintf(w, "Job title: %v\n", resp.GetTitle())
	}
}

자바

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


import com.google.cloud.talent.v4.Job;
import com.google.cloud.talent.v4.JobServiceClient;
import com.google.cloud.talent.v4.ListJobsRequest;
import com.google.cloud.talent.v4.TenantName;
import java.io.IOException;

public class JobSearchListJobs {

  public static void listJobs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String query = "count(base_compensation, [bucket(12, 20)])";
    listJobs(projectId, tenantId, query);
  }

  // Search Jobs with histogram queries.
  public static void listJobs(String projectId, String tenantId, String filter) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      TenantName parent = TenantName.of(projectId, tenantId);
      ListJobsRequest request =
          ListJobsRequest.newBuilder().setParent(parent.toString()).setFilter(filter).build();
      for (Job responseItem : jobServiceClient.listJobs(request).iterateAll()) {
        System.out.format("Job name: %s%n", responseItem.getName());
        System.out.format("Job requisition ID: %s%n", responseItem.getRequisitionId());
        System.out.format("Job title: %s%n", responseItem.getTitle());
        System.out.format("Job description: %s%n", responseItem.getDescription());
      }
    }
  }
}

Node.js

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


const talent = require('@google-cloud/talent').v4;

/**
 * List Jobs
 *
 * @param projectId {string} Your Google Cloud Project ID
 * @param tenantId {string} Identifier of the Tenant
 */
function sampleListJobs(projectId, tenantId, filter) {
  const client = new talent.JobServiceClient();
  // Iterate over all elements.
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const filter = 'companyName=projects/my-project/companies/company-id';
  const formattedParent = client.tenantPath(projectId, tenantId);
  const request = {
    parent: formattedParent,
    filter: filter,
  };

  client
    .listJobs(request)
    .then(responses => {
      const resources = responses[0];
      for (const resource of resources) {
        console.log(`Job name: ${resource.name}`);
        console.log(`Job requisition ID: ${resource.requisitionId}`);
        console.log(`Job title: ${resource.title}`);
        console.log(`Job description: ${resource.description}`);
      }
    })
    .catch(err => {
      console.error(err);
    });
}

Python

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


from google.cloud import talent
import six

def list_jobs(project_id, tenant_id, filter_):
    """List Jobs"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # filter_ = 'companyName=projects/my-project/companies/company-id'

    if isinstance(project_id, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(filter_, six.binary_type):
        filter_ = filter_.decode("utf-8")
    parent = f"projects/{project_id}/tenants/{tenant_id}"

    # Iterate over all results
    results = []
    for job in client.list_jobs(parent=parent, filter=filter_):
        results.append(job.name)
        print("Job name: {job.name}")
        print("Job requisition ID: {job.requisition_id}")
        print("Job title: {job.title}")
        print("Job description: {job.description}")
    return results

Ruby

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

require "google/cloud/talent"

# Instantiate a client
job_service = Google::Cloud::Talent.job_service

# project_id = "Your Google Cloud Project ID"
# tenant_id = "Your Tenant ID (using tenancy is required)"
formatted_parent = job_service.tenant_path project: project_id, tenant: tenant_id

# Iterate over all results.
# filter = "companyName=\"projects/my-project/companies/company-id\""
job_service.list_jobs(parent: formatted_parent, filter: filter).each do |element|
  puts "Job name: #{element.name}"
  puts "Job requisition ID: #{element.requisition_id}"
  puts "Job title: #{element.title}"
  puts "Job description: #{element.description}"
end

C#

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

public static object ListJobs(string projectId, string tenantId, string filter)
{
    JobServiceClient jobServiceClient = JobServiceClient.Create();

    TenantName tenantName = TenantName.FromProjectTenant(projectId, tenantId);
    ListJobsRequest request = new ListJobsRequest
    {
        ParentAsTenantName = tenantName,
        Filter = filter
    };
    PagedEnumerable<ListJobsResponse, Job> jobs = jobServiceClient.ListJobs(request);

    foreach (var job in jobs)
    {
        Console.WriteLine($"Job name: {job.Name}");
        Console.WriteLine($"Job requisition ID: {job.RequisitionId}");
        Console.WriteLine($"Job title: {job.Title}");
        Console.WriteLine($"Job description: {job.Description}");
    }
    return 0;
}

작업 삭제

Go

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

import (
	"context"
	"fmt"
	"io"

	talent "cloud.google.com/go/talent/apiv4beta1"
	talentpb "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"
)

// deleteJob deletes an existing job by its resource name.
func deleteJob(w io.Writer, projectID, jobID string) error {
	ctx := context.Background()

	// Initialize a jobService client.
	c, err := talent.NewJobClient(ctx)
	if err != nil {
		fmt.Printf("talent.NewJobClient: %v\n", err)
		return err
	}

	// Construct a deleteJob request.
	jobName := fmt.Sprintf("projects/%s/jobs/%s", projectID, jobID)
	req := &talentpb.DeleteJobRequest{
		// The resource name of the job to be deleted.
		// The format is "projects/{project_id}/jobs/{job_id}".
		Name: jobName,
	}

	if err := c.DeleteJob(ctx, req); err != nil {
		fmt.Printf("Delete(%s): %v\n", jobName, err)
		return err
	}

	fmt.Printf("Deleted job: %q\n", jobName)

	return err
}

자바

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


import com.google.cloud.talent.v4.DeleteJobRequest;
import com.google.cloud.talent.v4.JobName;
import com.google.cloud.talent.v4.JobServiceClient;
import java.io.IOException;

public class JobSearchDeleteJob {

  public static void deleteJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String tenantId = "your-tenant-id";
    String jobId = "your-job-id";
    deleteJob(projectId, tenantId, jobId);
  }

  // Delete Job.
  public static void deleteJob(String projectId, String tenantId, String jobId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create()) {
      JobName name = JobName.of(projectId, tenantId, jobId);

      DeleteJobRequest request = DeleteJobRequest.newBuilder().setName(name.toString()).build();

      jobServiceClient.deleteJob(request);
      System.out.println("Deleted job.");
    }
  }
}

Node.js

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


const talent = require('@google-cloud/talent').v4;

/** Delete Job */
function sampleDeleteJob(projectId, tenantId, jobId) {
  const client = new talent.JobServiceClient();
  // const projectId = 'Your Google Cloud Project ID';
  // const tenantId = 'Your Tenant ID (using tenancy is optional)';
  // const jobId = 'Company ID';
  const formattedName = client.jobPath(projectId, tenantId, jobId);
  client.deleteJob({name: formattedName}).catch(err => {
    console.error(err);
  });
  console.log('Deleted job.');
}

Python

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.


from google.cloud import talent
import six

def delete_job(project_id, tenant_id, job_id):
    """Delete Job"""

    client = talent.JobServiceClient()

    # project_id = 'Your Google Cloud Project ID'
    # tenant_id = 'Your Tenant ID (using tenancy is optional)'
    # job_id = 'Company ID'

    if isinstance(project_id, six.binary_type):
        project_id = project_id.decode("utf-8")
    if isinstance(tenant_id, six.binary_type):
        tenant_id = tenant_id.decode("utf-8")
    if isinstance(job_id, six.binary_type):
        job_id = job_id.decode("utf-8")
    name = client.job_path(project_id, tenant_id, job_id)

    client.delete_job(name=name)
    print("Deleted job.")

Ruby

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

require "google/cloud/talent"

# Instantiate a client
job_service = Google::Cloud::Talent.job_service

# project_id = "Your Google Cloud Project ID"
# tenant_id = "Your Tenant ID (using tenancy is required)"
# job_id = "Company ID"
formatted_name = job_service.job_path project: project_id,
                                      tenant:  tenant_id,
                                      job:     job_id

job_service.delete_job name: formatted_name

puts "Deleted job."

C#

Cloud Talent Solution 클라이언트 설치 및 만들기에 대한 자세한 내용은 Cloud Talent Solution 클라이언트 라이브러리를 참조하세요.

public static object DeleteJob(string projectId, string tenantId, string jobId)
{
    JobServiceClient jobServiceClient = JobServiceClient.Create();
    JobName jobName = JobName.FromProjectTenantJob(projectId, tenantId, jobId);
    DeleteJobRequest request = new DeleteJobRequest
    {
        JobName = jobName
    };

    jobServiceClient.DeleteJob(request);

    Console.WriteLine("Deleted Job.");
    return 0;
}

권장사항

위치 필드

가능한 한 addresses 필드에 채용정보의 상세 주소를 제공하는 것이 좋습니다. 이렇게 하면 위치 감지 및 관련성이 향상됩니다. 상세 주소를 제공할 수 없는 경우에는 가능한 많은 정보를 입력합니다. 주소는 국가 수준까지 지원됩니다. 지역 지정(예: '태평양 연안 북서부')은 지원되지 않습니다.

Cloud Talent Solution은 addresses 필드의 데이터를 사용하여(출력 전용) derivedInfo.locations 필드를 채웁니다. 전체 주소가 제공되지 않으면 서비스는 회사 이름 등의 기타 정보를 사용하여 채용 공고의 주소를 더 자세히 유추할 수 있는지 판단합니다.

예를 들어 소프트웨어 채용정보의 위치가 Mountain View로 지정되고 채용정보에 연관된 회사가 Google인 경우, 서비스는 company 객체를 찾아 headquartersAddress 필드에 더 정확한 주소가 제공되는지, 그리고 해당 주소가 채용 공고 도시와 동일한지 확인합니다. 만약 그렇다면 서비스는 채용정보가 상세 주소와 관련되었을 가능성이 높다고 판단하고 derivedInfo.locations 필드를 적절히 채웁니다.

회사 주소 데이터를 사용할 수 없는 경우 서비스는 독점 지식과 채용정보/회사 정보를 조합하여 derivedInfo.locations 필드에 입력합니다.

derivedInfo.locations 값이 최선의 추측이므로 채용정보 주소를 표시할 때 derivedInfo.locations 데이터 또는 addresses 필드를 사용할 수 있습니다.

각 채용 공고마다 위치가 최대 50개까지 연결될 수 있습니다. 채용정보 위치가 이보다 많으면 채용정보를 각각 고유한 requisitionId(예: 'ReqA' , 'ReqA-1', 'ReqA-2' 등)가 있는 여러 채용정보로 분할할 수 있습니다. 여러 채용정보는 동일한 requisitionId, companyName, languageCode를 가질 수 없기 때문입니다. requisitionId를 그대로 유지해야 한다면 CustomAttribute를 스토리지로 사용해야 합니다. 검색 환경을 개선하려면 동일한 채용정보에서 서로 가장 가까운 위치를 그룹화하는 것이 좋습니다.

지원되는 주소

Cloud Talent Solution은 Google Maps Geocoding API가 인식하는 (formattedAddress 필드) 모든 주소를 허용합니다. 이 서비스는 인식되지 않는 주소를 사용하여 채용정보를 만들거나 검색을 실행하려 하면 400 오류를 반환합니다.

회사 주소가 Google Maps Geocoding API에 잘못 등록된 경우 버그를 신고하여 정정합니다. 수정사항이 적용되는 데 최대 5일이 걸릴 수 있습니다.

주소 자동 완성

Cloud Talent Solution은 위치 자동 완성을 제안하지 않습니다. 자동 완성 채우기를 제안하려면 Google Maps Places API 또는 기타 유사한 위치 서비스를 사용합니다.

시/도 단위, 전국 단위, 재택 근무 채용정보

postingRegion 필드를 사용하면 채용정보를 주/도 단위, 전국 단위 또는 재택 근무로 지정할 수 있습니다.

  • ADMINISTRATIVE_AREANATION 채용정보는 채용 공고의 시/도 또는 국가에 속하는 위치를 사용한 모든 검색에서 반환됩니다. 예를 들어 ADMINISTRATIVE_AREA 채용정보의 위치가 'WA, USA'인 경우 '시애틀'로 지정된 검색에 대해 LocationFilter가 반환됩니다.

  • TELECOMMUTE 채용정보는 모든 위치 관련 검색에서 반환되지만 관련성이 낮은 것으로 취급됩니다. 검색에서 이러한 채용정보를 대상으로 지정하려면 검색의 LocationFilter에서 telecommutePreference 플래그를 TELECOMMUTE_ALLOWED로 설정합니다.