本教程旨在引导您利用 Cloud Talent Solution 探索和开发应用。它假设您熟悉基本编程；但即使没有太多的编程知识，您也应该能够按照说明操作。完成本教程后，您应该能够借助参考文档创建自己的基本应用。 此外，还有视频教程和交互式 Codelab 可供使用。如果您有任何疑问，请与我们联系。
前提条件
您已完成以下操作：
- 如准备工作所述，完成创建和设置项目的步骤，
- 使用应用默认凭据设置好了环境，
- 基本熟悉 Java 或 Python 编程，
- 安装了最新版本的 Google API Java 客户端或 Google API Python 客户端。
创建一个公司及其职位，并搜索这些职位
本教程将为您介绍基本的 Cloud Talent Solution 应用，并引导您创建一个关联到公司资源的职位资源。下一个教程将为您介绍基于职位属性和搜索查询来搜索公司内职位的步骤。search API 会尝试根据招聘信息中的可用字段（公司名称、职位、职位描述、职位类别、工作地点等）返回与求职者查询相关性最高的招聘信息。
创建公司
公司是与一组职位列表关联的实体。您必须先创建公司对象，才能在 Cloud Talent Solution 上发布该公司的职位。
创建公司时，您可以将任何自由格式的字符串作为 externalId 发送。这意味着您在创建和引用公司时，可以使用现有数据库（如果有）中的主键。
Go
如需了解如何安装和使用适用于 CTS 的客户端库，请参阅 CTS 客户端库。 如需了解详情，请参阅 CTS Go API 参考文档。
如需向 CTS 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
import (
"context"
"fmt"
"io"
talent "cloud.google.com/go/talent/apiv4beta1"
"cloud.google.com/go/talent/apiv4beta1/talentpb"
)
// createCompany creates a company as given.
func createCompany(w io.Writer, projectID, externalID, displayName string) (*talentpb.Company, error) {
ctx := context.Background()
// Initializes a companyService client.
c, err := talent.NewCompanyClient(ctx)
if err != nil {
return nil, fmt.Errorf("talent.NewCompanyClient: %w", err)
}
defer c.Close()
// Construct a createCompany request.
req := &talentpb.CreateCompanyRequest{
Parent: fmt.Sprintf("projects/%s", projectID),
Company: &talentpb.Company{
ExternalId: externalID,
DisplayName: displayName,
},
}
resp, err := c.CreateCompany(ctx, req)
if err != nil {
return nil, fmt.Errorf("CreateCompany: %w", err)
}
fmt.Fprintf(w, "Created company: %q\n", resp.GetName())
return resp, nil
}
Java
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
import com.google.cloud.talent.v4beta1.Company;
import com.google.cloud.talent.v4beta1.CompanyServiceClient;
import com.google.cloud.talent.v4beta1.CreateCompanyRequest;
import com.google.cloud.talent.v4beta1.TenantName;
import java.io.IOException;
public class JobSearchCreateCompany {
public static void createCompany() throws IOException {
// TODO(developer): Replace these variables before running the sample.
String projectId = "your-project-id";
String tenantId = "your-tenant-id";
String displayName = "your-company-display-name";
String externalId = "your-external-id";
createCompany(projectId, tenantId, displayName, externalId);
}
// Create a company.
public static void createCompany(
String projectId, String tenantId, String displayName, String externalId) 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 (CompanyServiceClient companyServiceClient = CompanyServiceClient.create()) {
TenantName parent = TenantName.of(projectId, tenantId);
Company company =
Company.newBuilder().setDisplayName(displayName).setExternalId(externalId).build();
CreateCompanyRequest request =
CreateCompanyRequest.newBuilder()
.setParent(parent.toString())
.setCompany(company)
.build();
Company response = companyServiceClient.createCompany(request);
System.out.println("Created Company");
System.out.format("Name: %s%n", response.getName());
System.out.format("Display Name: %s%n", response.getDisplayName());
System.out.format("External ID: %s%n", response.getExternalId());
}
}
}Python
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
from google.cloud import talent
def create_company(project_id, tenant_id, display_name, external_id):
"""Create Company"""
client = talent.CompanyServiceClient()
# project_id = 'Your Google Cloud Project ID'
# tenant_id = 'Your Tenant ID (using tenancy is optional)'
# display_name = 'My Company Name'
# external_id = 'Identifier of this company in my system'
if isinstance(project_id, bytes):
project_id = project_id.decode("utf-8")
if isinstance(tenant_id, bytes):
tenant_id = tenant_id.decode("utf-8")
if isinstance(display_name, bytes):
display_name = display_name.decode("utf-8")
if isinstance(external_id, bytes):
external_id = external_id.decode("utf-8")
parent = f"projects/{project_id}/tenants/{tenant_id}"
company = {"display_name": display_name, "external_id": external_id}
response = client.create_company(parent=parent, company=company)
print("Created Company")
print(f"Name: {response.name}")
print(f"Display Name: {response.display_name}")
print(f"External ID: {response.external_id}")
return response.name
创建作业
要发布新的职位资源，您必须提供与该职位相关的所有必填字段，以及您要将此职位关联到的公司的 companyName。在创建公司资源时，您已指定了 companyName。
填妥职位数据的数据对象通过 POST 请求发送到 Cloud Talent Solution 端点。不应在初始请求中设置 name 字段，因为它是 createJob API 的“仅限输出”字段：在服务器创建新的职位实体时，它是 API 响应的一部分。用于与职位资源交互的 API 端点在 Cloud Talent Solution 客户端库文档中指定。
该请求的响应是一个新的职位对象。它应包含唯一表示信息帖的职位 name。需要更新或删除信息帖时会用到职位 name。最佳做法是，保存此 name 并将其与您自己对该职位的唯一 ID 对应。
当您尝试创建新的职位时，如果系统中已存在另一个具有相同 companyName、requisitionId 和 languageCode 的职位，则服务器将返回错误。
通过 Cloud Talent Solution，您还可以创建针对特定地点的职位。
如需了解详情，请参阅 locations。
以下代码仅使用必需字段为 companyName 字段中指定的公司创建职位。
您可以使用以下代码示例创建职位。 如需了解详情，请参阅快速入门：创建公司和职位。
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"
)
// 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
}
Java
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
import com.google.cloud.talent.v4beta1.CreateJobRequest;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.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";
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());
}
}
}Python
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
from google.cloud import talent
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, bytes):
project_id = project_id.decode("utf-8")
if isinstance(tenant_id, bytes):
tenant_id = tenant_id.decode("utf-8")
if isinstance(company_id, bytes):
company_id = company_id.decode("utf-8")
if isinstance(requisition_id, bytes):
requisition_id = requisition_id.decode("utf-8")
if isinstance(job_application_url, bytes):
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(f"Created job: {response.name}")
return response.name
使用自定义字段创建职位
Cloud Talent Solution 包含很多内置于 API 架构中的职位字段。但是，您仍然可能需要一些开箱即用选项中不存在的其他字段。虽然我们建议您尽可能使用开箱即用的字段，但 Cloud Talent Solution 还是为职位提供了一些 customAttributes 字段。这些字段可能可以过滤，也可能不可过滤。如需了解详情，请参阅 customAttributes 文档。
以下代码示例显示了如何使用 customAttribute 创建职位：
Go
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
import (
"context"
"fmt"
"io"
talent "cloud.google.com/go/talent/apiv4beta1"
"cloud.google.com/go/talent/apiv4beta1/talentpb"
"github.com/gofrs/uuid"
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: %w", err)
}
defer c.Close()
// 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: %w", 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
}
Java
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
import com.google.cloud.talent.v4beta1.CreateJobRequest;
import com.google.cloud.talent.v4beta1.CustomAttribute;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobServiceClient;
import com.google.cloud.talent.v4beta1.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());
}
}
}Python
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
from google.cloud import talent
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, bytes):
project_id = project_id.decode("utf-8")
if isinstance(tenant_id, bytes):
tenant_id = tenant_id.decode("utf-8")
if isinstance(company_id, bytes):
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
检索职位
您可以通过 GET 操作获取职位的详细信息，以确认职位是否已创建。请注意，根据 Cloud Talent Solution 中当前创建的职位数量，新创建的职位可能需要数分钟才可检索。
您可以向 Cloud Talent Solution API 发送 GET 请求，以检索之前插入的职位的详细信息。URI 应包含原始 CREATE 请求以网址参数形式返回的之前插入的职位 name。
以下示例通过 GET 操作检索具有给定 name 的职位的详细信息：
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
}
Java
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
import com.google.cloud.talent.v4beta1.GetJobRequest;
import com.google.cloud.talent.v4beta1.Job;
import com.google.cloud.talent.v4beta1.JobName;
import com.google.cloud.talent.v4beta1.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.ofProjectTenantJobName(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);
}
}
}
}Python
如需详细了解如何安装和创建 Cloud Talent Solution 客户端，请参阅 Cloud Talent Solution 客户端库。
from google.cloud import talent
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, bytes):
project_id = project_id.decode("utf-8")
if isinstance(tenant_id, bytes):
tenant_id = tenant_id.decode("utf-8")
if isinstance(job_id, bytes):
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}")
搜索职位
您已经使用 Cloud Talent Solution 创建了第一家公司和第一个职位！您现在可以对这些职位进行搜索。
更多 API
如需详细了解 API 和可用的不同配置，请参阅最新的参考文档。