Esta página foi traduzida pela API Cloud Translation.
Switch to English

Princípios básicos de vagas

Um recurso Vaga representa uma postagem de vaga de trabalho (também conhecida como "anúncio de emprego" ou "requisição de trabalho"). Uma vaga pertence a um recurso Empresa, que representa a entidade de contratação responsável por ela.

É possível acessar uma vaga usando os métodos LIST e GET e manipulá-la usando os métodos CREATE, UPDATE e DELETE. Pode levar vários minutos para o índice do Cloud Talent Solution refletir as alterações.

As vagas estão contidas no escopo de uma conta de serviço. Somente as solicitações de pesquisa autenticadas por meio de credenciais de uma conta de serviço específica podem ser usadas para acessar o conteúdo dessas vagas.

Para facilitar a solução de problemas e a triagem, sincronize o índice da vaga do Cloud Talent Solution com seu próprio índice de vaga e mantenha um relacionamento entre o name gerado pelo Cloud Talent Solution e o identificador de vaga exclusivo em seu sistema. À medida que as vagas mudam ou são introduzidas em seu sistema, a chamada CRUD apropriada precisa ser enviada ao CTS em tempo real para garantir que essas alterações sejam refletidas imediatamente. O índice CTS precisa ser adicionado ao pipeline de processamento de vagas atual.

Criar uma vaga

É possível criar uma vaga usando o exemplo de código abaixo. Veja Início rápido: criar empresas e vagas para mais detalhes. Também estão disponíveis tutoriais em vídeo e codelabs interativos.

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
}

Java

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Campos obrigatórios

Os seguintes campos são obrigatórios durante a criação e a atualização da vaga:

  • companyName: o nome do recurso da empresa que disponibiliza a vaga, como companyName=\"projects/{ProjectId}/companies/{CompanyId}\".

  • requisitionId: o ID da requisição, também chamado de ID de postagem, é um valor que você atribui para identificar uma vaga. É possível usar esse campo para identificação de clientes e rastreamento de requisições. O número máximo de caracteres permitidos é 225.

    A exclusividade de uma postagem de vaga é determinada usando uma combinação de requisitionID, companyName e local. Caso uma vaga seja criada com uma chave específica desses atributos, essa chave será armazenada no índice da Cloud Talent Solution, e nenhuma outra vaga com esses mesmos campos poderá ser criada até a exclusão dessa vaga.

  • title: o cargo da vaga, por exemplo "Engenheiro de software". O número máximo de caracteres permitidos é 500.

    Para corrigir o problema de resultados de pesquisa perdidos devido a cargos não padronizados, o Cloud Talent Solution aproveita todos os campos da vaga para entender o contexto dela e armazena internamente um cargo "limpo". Quando uma solicitação de pesquisa é enviada para o serviço, a consulta da pesquisa também é limpa, e as ontologias são usadas a fim de mapear a consulta limpa para vagas limpas relevantes.

  • description: a descrição da vaga, que normalmente inclui uma descrição de vários parágrafos sobre a empresa e informações relacionadas. Campos separados são fornecidos no objeto da vaga para responsabilidades, qualificações e outras características dela. É recomendado o uso desses campos separados.

    Esse campo aceita e limpa a entrada HTML, além de aceitar tags de marcação, como negrito, itálico, lista ordenada e lista não ordenada. O número máximo de caracteres permitidos é 100.000.

Opções:

  • applicationInfo.uris: o(s) URL(s) da(s) página(s) do aplicativo.

  • applicationInfo.emails: endereço(s) de email para que os currículos ou aplicativos devem ser enviados.

  • applicationInfo.instruction: instruções para se candidatar, como "Envie sua inscrição para...". Esse campo aceita e limpa a entrada HTML, além de aceitar tags de marcação, como negrito, itálico, lista ordenada e lista não ordenada. O número máximo de caracteres permitidos é 3.000.

Campos mais usados

  • postingExpireTime: a hora em que a postagem de vaga expira, com base no carimbo de data e hora. Após essa hora, a vaga será marcada como expirada e não aparecerá nos resultados da pesquisa. Essa data precisa ser anterior a 31/12/2100 no fuso horário UTC. As datas inválidas (como passadas) são ignoradas. A data padrão de expiração da vaga é 30 dias após a hora de criação da vaga no fuso horário UTC.

    O conteúdo de jobs expirados ainda pode ser recuperado até 90 dias após a expiração do job usando o operador GET. Após esse prazo de 90 dias, o job não será retornado por meio de uma operação GET.

  • addresses: local (ou locais) de trabalho. É recomendável informar o endereço completo do local de contratação para permitir melhores resultados na pesquisa de vagas, inclusive pesquisas por tempo de deslocamento diário. O número máximo de caracteres permitidos é 500. Veja mais informações sobre addresses na seção Práticas recomendadas abaixo.

  • promotionValue: um valor maior que 0 define essa vaga como "vaga em destaque", que é retornada apenas nas pesquisas do tipo FEATURED_JOBS. Valores mais altos ficam em posições mais elevadas nos resultados da pesquisa em destaque. Consulte Vagas em destaque para mais informações.

Como usar os campos de vagas personalizados

O Cloud Talent Solution inclui vários campos de vagas incorporados ao esquema da API. No entanto, pode ser preciso adicionar campos extras que não estão presentes nas opções prontas para uso. Embora seja recomendável usar os campos prontos sempre que possível, o Cloud Talent Solution também fornece alguns campos customAttributes para uma vaga. Eles podem ser filtráveis ou não filtráveis. Consulte a documentação de customAttributes para mais informações.

  • customAttributes: esse campo armazena até 100 atributos personalizados usados para armazenar dados personalizados sobre a vaga. Esses campos podem ser filtrados usando um pedido de pesquisa especificando o campo jobQuery. Além disso, qualquer um desses campos pode ser definido no atributo keywordSearchableJobCustomAttributes da company. Portanto, um termo de pesquisa que tenha uma correspondência exata em qualquer um dos campos em keywordSearchableJobCustomAttributes retorna qualquer vaga que tenha essa correspondência.

O exemplo de código a seguir mostra como criar uma vaga com customAttribute:

Go

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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
}

Java

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Recuperar uma vaga

Go

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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}")

Listar jobs

Go

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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())
	}
}

Java

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Excluir um job

Go

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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
}

Java

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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

Para mais informações sobre a instalação e criação de um cliente no Cloud Talent Solution, consulte a Bibliotecas de clientes do 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.")

Práticas recomendadas

Campos de local

Sempre que possível, recomendamos fornecer o endereço de uma vaga no campo addresses. Isso ajuda na detecção e na relevância do local. Quando um endereço no nível da rua não estiver disponível, especifique o máximo de informações possível. Os endereços são compatíveis até o nível do país. Designações de região (como "Noroeste do Pacífico") não são permitidas.

O Cloud Talent Solution usa os dados no campo addresses para preencher o campo derivedInfo.locations (somente saída). Quando um endereço completo não for fornecido, o serviço usará outros sinais, como o nome da empresa, para determinar se um endereço mais completo pode ser inferido para a postagem da vaga.

Por exemplo, se o local de um cargo de software for especificado como Mountain View e a empresa a que a vaga esteja associada for Google, o serviço procurará o objeto company para ver se um endereço melhor é fornecido no campo headquartersAddress e se esse endereço está na mesma cidade que a postagem da vaga. Nesse caso, o serviço entende que a vaga está "provavelmente" localizada nesse endereço e preenche o campo derivedInfo.locations adequadamente.

Se os dados de endereço da empresa não estiverem disponíveis, o serviço utilizará uma combinação de conhecimento proprietário e informações da vaga/empresa para informar no campo derivedInfo.locations.

Como o valor derivedInfo.locations é um esforço de melhor estimativa, use os dados derivedInfo.locations ou o campo addresses ao exibir o endereço da vaga.

Uma postagem de vaga pode ter, no máximo, 50 locais associados. Se uma vaga tiver mais locais, divida-a em várias vagas, cada uma com um requisitionId exclusivo. Por exemplo, "ReqA", "ReqA-1", "ReqA-2" etc. Não são permitidas várias vagas com os mesmos requisitionId, companyName e languageCode. Para preservar o requisitionId original, será necessário usar um CustomAttribute no armazenamento. É recomendável agrupar os locais mais próximos entre si na mesma vaga para uma melhor experiência de pesquisa.

Endereços compatíveis

Qualquer endereço reconhecido pela API Geocoding do Google Maps (no campo formattedAddress) é aceito pelo Cloud Talent Solution. O serviço retornará um erro 400 se você tentar criar uma vaga ou executar uma pesquisa usando um endereço não reconhecido.

Se um endereço comercial estiver listado incorretamente na API Geocoding Google Maps, registre um bug para corrigi-lo. As correções podem levar até cinco dias para entrar em vigor.

Preenchimento automático de endereços

A Cloud Talent Solution não fornece sugestões de preenchimento automático para locais. Use a API Google Maps Places, ou outros serviços de localização semelhantes, para inserir sugestões de preenchimento automático.

Vagas estaduais, nacionais e remotas

As vagas podem ser especificadas como estaduais, nacionais ou remotas usando o campo postingRegion.

  • As vagas ADMINISTRATIVE_AREA e NATION são retornadas para qualquer pesquisa em um local especificado dentro do estado/país da publicação da vaga. Por exemplo, se uma vaga ADMINISTRATIVE_AREA tiver um local "WA, EUA", ela será retornado para pesquisas com LocationFilter especificando "Seattle".

  • As vagas TELECOMMUTE são retornadas em qualquer pesquisa relacionada ao local, mas são tratadas como menos relevantes. Elas podem ser direcionadas em uma pesquisa definindo a sinalização telecommutePreference para TELECOMMUTE_ALLOWED no LocationFilter da pesquisa.