Crea una empresa y un trabajo en Talent Solution

Este instructivo está diseñado para que comiences a explorar y desarrollar aplicaciones con Cloud Talent Solution. Se espera que estés familiarizado con la programación básica, aunque deberías poder seguir la guía sin tener mucho conocimiento sobre programación. Cuando completes este instructivo, podrás usar la documentación de referencia de Cloud Talent Solution para crear tus propias aplicaciones básicas.

En este instructivo, se explica una aplicación de Cloud Talent Solution que usa código de Java. El propósito del instructivo no es explicar las bibliotecas cliente de Java, sino explicar cómo hacer llamadas a Cloud Talent Solution. Las aplicaciones de Python y Node.js son similares básicamente. Comunícate con nosotros si tienes alguna pregunta.

Antes de comenzar

Aprendiste a realizar lo siguiente:

seguir los pasos para crear y configurar tu proyecto, como se indica en Antes de comenzar
configurar tu entorno con las credenciales predeterminadas de la aplicación
estar familiarizado con los aspectos básicos de la programación en Java o Python
instalar la versión más reciente del cliente de la API de Google para Java o Python

Crea una empresa con trabajos y búscalos

En este instructivo, se explica una aplicación básica de Cloud Talent Solution y se indican instrucciones para crear un trabajo asociado con una empresa. El instructivo siguiente indica los pasos para buscar trabajos en la empresa según los atributos de los trabajos y de la búsqueda. La API de search intenta mostrar los trabajos más relevantes para la consulta del usuario según los campos disponibles de un trabajo (nombre de la empresa, cargo, descripción del trabajo, categorías del trabajo, ubicación del trabajo, etcétera).

Crea un servicio con tus credenciales

Crea el servicio con el archivo de credencial JSON que descargaste en Antes de comenzar. Para ello, sigue estos ejemplos:

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


private static final JsonFactory JSON_FACTORY = new GsonFactory();
private static final NetHttpTransport NET_HTTP_TRANSPORT = new NetHttpTransport();
private static final String DEFAULT_PROJECT_ID =
    "projects/" + System.getenv("GOOGLE_CLOUD_PROJECT");

private static CloudTalentSolution talentSolutionClient =
    createTalentSolutionClient(generateCredential());

private static CloudTalentSolution createTalentSolutionClient(GoogleCredentials credential) {
  String url = "https://jobs.googleapis.com";

  HttpRequestInitializer requestInitializer =
      request -> {
        new HttpCredentialsAdapter(credential).initialize(request);
        request.setConnectTimeout(60000); // 1 minute connect timeout
        request.setReadTimeout(60000); // 1 minute read timeout
      };

  return new CloudTalentSolution.Builder(NET_HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
      .setApplicationName("JobServiceClientSamples")
      .setRootUrl(url)
      .build();
}

private static GoogleCredentials generateCredential() {
  try {
    // Credentials could be downloaded after creating service account
    // set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable, for example:
    // export GOOGLE_APPLICATION_CREDENTIALS=/path/to/your/key.json
    return GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(CloudTalentSolutionScopes.JOBS));
  } catch (Exception e) {
    System.out.println("Error in generating credential");
    throw new RuntimeException(e);
  }
}

public static CloudTalentSolution getTalentSolutionClient() {
  return talentSolutionClient;
}

public static void main(String... args) throws Exception {
  try {
    ListCompaniesResponse listCompaniesResponse =
        talentSolutionClient.projects().companies().list(DEFAULT_PROJECT_ID).execute();
    System.out.println("Request Id is " + listCompaniesResponse.getMetadata().getRequestId());
    if (listCompaniesResponse.getCompanies() != null) {
      for (Company company : listCompaniesResponse.getCompanies()) {
        System.out.println(company.getName());
      }
    }
  } catch (IOException e) {
    System.out.println("Got exception while listing companies");
    throw e;
  }
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

import os

from googleapiclient.discovery import build
from googleapiclient.errors import Error

client_service = build("jobs", "v3")

def run_sample():
    try:
        project_id = "projects/" + os.environ["GOOGLE_CLOUD_PROJECT"]
        response = (
            client_service.projects().companies().list(parent=project_id).execute()
        )
        print("Request Id: %s" % response.get("metadata").get("requestId"))
        print("Companies:")
        if response.get("companies") is not None:
            for company in response.get("companies"):
                print("%s" % company.get("name"))
        print("")

    except Error as e:
        print("Got exception while listing companies")
        raise e

if __name__ == "__main__":
    run_sample()

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// Command quickstart is an example of using the Google Cloud Talent Solution API.
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"golang.org/x/oauth2/google"
	talent "google.golang.org/api/jobs/v3"
)

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	parent := fmt.Sprintf("projects/%s", projectID)

	// Authorize the client using Application Default Credentials.
	// See https://g.co/dv/identity/protocols/application-default-credentials
	ctx := context.Background()
	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		log.Fatal(err)
	}

	// Create the jobs service client.
	ctsService, err := talent.New(client)
	if err != nil {
		log.Fatal(err)
	}

	// Make the RPC call.
	response, err := ctsService.Projects.Companies.List(parent).Do()
	if err != nil {
		log.Fatalf("Failed to list Companies: %v", err)
	}

	// Print the request id.
	fmt.Printf("Request ID: %q\n", response.Metadata.RequestId)

	// Print the returned companies.
	for _, company := range response.Companies {
		fmt.Printf("Company: %q\n", company.Name)
	}
}

Este código configura el servicio del cliente con la información de credenciales de tu aplicación. La solicitud de OAuth 2.0 se envía cuando se realiza una llamada a la API. El token de autenticación que se genera con el proceso anterior suele ser válido por 1 hora, tras la cual recibirás un error si intentas usarlo. La biblioteca GoogleCredential se encarga de “actualizar” el token de manera automática, es decir, obtener un token de acceso nuevo.

Crea una empresa

Una empresa es una entidad asociada a un conjunto de publicaciones de trabajo. Debes crear una empresa para poder publicar sus trabajos en Cloud Talent Solution. Puedes enviar cualquier string de formato libre como el externalId cuando crees una empresa. Es decir, puedes usar la clave primaria de tu base de datos existente (si tienes una) cuando crees una empresa y hagas referencia a ella.

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


/** Create a company. */
public static Company createCompany(Company companyToBeCreated) throws IOException {
  try {
    CreateCompanyRequest createCompanyRequest =
        new CreateCompanyRequest().setCompany(companyToBeCreated);
    Company companyCreated =
        talentSolutionClient
            .projects()
            .companies()
            .create(DEFAULT_PROJECT_ID, createCompanyRequest)
            .execute();
    System.out.println("Company created: " + companyCreated);
    return companyCreated;
  } catch (IOException e) {
    System.out.println("Got exception while creating company");
    throw e;
  }
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

def create_company(client_service, company_to_be_created):
    try:
        request = {"company": company_to_be_created}
        company_created = (
            client_service.projects()
            .companies()
            .create(parent=parent, body=request)
            .execute()
        )
        print("Company created: %s" % company_created)
        return company_created
    except Error as e:
        print("Got exception while creating company")
        raise e

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// createCompany creates a company as given.
func createCompany(w io.Writer, projectID string, companyToCreate *talent.Company) (*talent.Company, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	parent := "projects/" + projectID
	req := &talent.CreateCompanyRequest{
		Company: companyToCreate,
	}
	company, err := service.Projects.Companies.Create(parent, req).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to create company %q: %w", companyToCreate.DisplayName, err)
	}

	return company, nil
}

Recupera una empresa

Puedes leer el estado actual de una empresa mediante una solicitud GET, junto con el name de la empresa que asignó nuestro backend.

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


/** Get a company. */
public static Company getCompany(String companyName) throws IOException {
  try {
    Company companyExisted =
        talentSolutionClient.projects().companies().get(companyName).execute();
    System.out.println("Company existed: " + companyExisted);
    return companyExisted;
  } catch (IOException e) {
    System.out.println("Got exception while getting company");
    throw e;
  }
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

def get_company(client_service, company_name):
    try:
        company_existed = (
            client_service.projects().companies().get(name=company_name).execute()
        )
        print("Company existed: %s" % company_existed)
        return company_existed
    except Error as e:
        print("Got exception while getting company")
        raise e

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// getCompany gets an existing company by name.
func getCompany(w io.Writer, name string) (*talent.Company, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	company, err := service.Projects.Companies.Get(name).Do()
	if err != nil {
		return nil, fmt.Errorf("failed to get company %q: %w", name, err)
	}

	fmt.Fprintf(w, "Company: %q\n", company.Name)

	return company, nil
}

Crear trabajo

Para publicar un trabajo nuevo, debes proporcionar todos sus campos obligatorios junto con el companyName de la empresa con la que deseas asociarlo, que especificaste cuando creaste el recurso de la empresa.

El objeto de datos con los datos del trabajo completados se envía al extremo de Cloud Talent Solution mediante una solicitud POST. Ten en cuenta que el campo name no se debe configurar en la solicitud inicial, ya que es un campo de “solo salida” de la API de createJob y forma parte de la respuesta de la API cuando un servidor crea una entidad de trabajo nueva. El extremo de la API que interactuará con el recurso de Job se especifica en el documento Bibliotecas cliente de Cloud Talent Solution.

La respuesta a la solicitud es un objeto de la nueva publicación de trabajo; debe incluir un name de trabajo que represente de forma exclusiva la publicación. El name de trabajo se utiliza cuando la publicación necesita actualizarse o eliminarse. Como práctica recomendada, almacene este name y asócielo con su propia ID única para el trabajo.

El servidor mostrará un error si intentas insertar un trabajo cuando ya existe otro en el sistema con los mismos companyName, requisitionId y languageCode en la misma empresa.

Con el siguiente código, se crea un trabajo con solo los campos obligatorios para la empresa especificada en el campo companyName.

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


/** Create a job. */
public static Job createJob(Job jobToBeCreated) throws IOException {
  try {
    CreateJobRequest createJobRequest = new CreateJobRequest().setJob(jobToBeCreated);

    Job jobCreated =
        talentSolutionClient
            .projects()
            .jobs()
            .create(DEFAULT_PROJECT_ID, createJobRequest)
            .execute();
    System.out.println("Job created: " + jobCreated);
    return jobCreated;
  } catch (IOException e) {
    System.out.println("Got exception while creating job");
    throw e;
  }
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

def create_job(client_service, job_to_be_created):
    try:
        request = {"job": job_to_be_created}
        job_created = (
            client_service.projects()
            .jobs()
            .create(parent=parent, body=request)
            .execute()
        )
        print("Job created: %s" % job_created)
        return job_created
    except Error as e:
        print("Got exception while creating job")
        raise e

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// createJob create a job as given.
func createJob(w io.Writer, projectID string, jobToCreate *talent.Job) (*talent.Job, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	parent := "projects/" + projectID
	req := &talent.CreateJobRequest{
		Job: jobToCreate,
	}
	job, err := service.Projects.Jobs.Create(parent, req).Do()
	if err != nil {
		return nil, fmt.Errorf("Failed to create job %q, Err: %w", jobToCreate.RequisitionId, err)
	}
	return job, err
}

Cloud Talent Solution también permite crear trabajos específicos de una ubicación. Consulta locations para obtener más información.

Cloud Talent Solution cuenta con varios campos asociados a un trabajo que están integrados en el esquema de la API. Sin embargo, es posible que todavía tengas campos que no forman parte de los campos integrados. Si bien se recomienda que todos los clientes de Cloud Talent Solution usen siempre los campos integrados cuando sea posible, también se proporcionan algunos atributos personalizados (customAttributes) para los trabajos. Algunos de ellos se pueden usar en los filtros. Consulta customAttributes para obtener más información.

En el siguiente ejemplo de código, se muestra cómo crear un trabajo con un customAttribute:

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


/** Generate a job with a custom attribute. */
@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public static Job generateJobWithACustomAttribute(String companyName) {
  // requisition id should be a unique Id in your system.
  String requisitionId = "jobWithACustomAttribute:" + String.valueOf(new Random().nextLong());
  ApplicationInfo applicationInfo =
      new ApplicationInfo().setUris(Arrays.asList("http://careers.google.com"));

  // Constructs custom attributes map
  Map<String, CustomAttribute> customAttributes = new HashMap<>();
  customAttributes.put(
      "someFieldName1",
      new CustomAttribute().setStringValues(Arrays.asList("value1")).setFilterable(Boolean.TRUE));
  customAttributes.put(
      "someFieldName2",
      new CustomAttribute().setLongValues(Arrays.asList(256L)).setFilterable(true));

  // Creates job with custom attributes
  Job job =
      new Job()
          .setCompanyName(companyName)
          .setRequisitionId(requisitionId)
          .setTitle("Software Engineer")
          .setApplicationInfo(applicationInfo)
          .setDescription("Design, develop, test, deploy, maintain and improve software.")
          .setCustomAttributes(customAttributes);
  System.out.println("Job generated: " + job);
  return job;
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

def generate_job_with_custom_attributes(company_name):
    # Requisition id should be a unique Id in your system.
    requisition_id = "job_with_custom_attributes:" + "".join(
        random.choice(string.ascii_uppercase + string.digits) for _ in range(16)
    )

    job_title = "Software Engineer"
    application_urls = ["http://careers.google.com"]
    description = "Design, develop, test, deploy, maintain and improve " "software."

    custom_attributes = {
        "someFieldName1": {"string_values": ["value1"], "filterable": True},
        "someFieldName2": {"long_values": [256], "filterable": True},
    }

    job = {
        "company_name": company_name,
        "requisition_id": requisition_id,
        "title": job_title,
        "application_info": {"uris": application_urls},
        "description": description,
        "custom_attributes": custom_attributes,
    }
    print("Job generated: %s" % job)
    return job

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// constructJobWithCustomAttributes constructs a job with custom attributes.
func constructJobWithCustomAttributes(companyName string, jobTitle string) *talent.Job {
	// requisitionID shoud be the unique ID in your system
	requisitionID := fmt.Sprintf("job-with-custom-attribute-%d", time.Now().UnixNano())

	job := &talent.Job{
		RequisitionId: requisitionID,
		Title:         jobTitle,
		CompanyName:   companyName,
		ApplicationInfo: &talent.ApplicationInfo{
			Uris: []string{"https://googlesample.com/career"},
		},
		Description: "Design, devolop, test, deploy, maintain and improve software.",
		CustomAttributes: map[string]talent.CustomAttribute{
			"someFieldString": {
				Filterable:   true,
				StringValues: []string{"someStrVal"},
			},
			"someFieldLong": {
				Filterable: true,
				LongValues: []int64{900},
			},
		},
	}
	return job
}

Recupera un trabajo

Puedes confirmar la creación de un trabajo con una operación GET para obtener sus detalles. Ten en cuenta que la disponibilidad del trabajo puede tardar algunos minutos en función del volumen actual de trabajos que se estén creando en Cloud Talent Solution.

Para recuperar los detalles de un trabajo insertado anteriormente, envía una solicitud GET a Cloud Talent Solution. El URI debe incluir el name de trabajo insertado previamente devuelto por la solicitud de creación original, como un parámetro de URL.

En el siguiente ejemplo, se usa una operación GET para recuperar los detalles con un namedeterminado:

Java

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


/** Get a job. */
public static Job getJob(String jobName) throws IOException {
  try {
    Job jobExisted = talentSolutionClient.projects().jobs().get(jobName).execute();
    System.out.println("Job existed: " + jobExisted);
    return jobExisted;
  } catch (IOException e) {
    System.out.println("Got exception while getting job");
    throw e;
  }
}

Python

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.

def get_job(client_service, job_name):
    try:
        job_existed = client_service.projects().jobs().get(name=job_name).execute()
        print("Job existed: %s" % job_existed)
        return job_existed
    except Error as e:
        print("Got exception while getting job")
        raise e

Go

Consulta Bibliotecas cliente de Cloud Talent Solution para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution.


// getJob gets a job by name.
func getJob(w io.Writer, jobName string) (*talent.Job, error) {
	ctx := context.Background()

	client, err := google.DefaultClient(ctx, talent.CloudPlatformScope)
	if err != nil {
		return nil, fmt.Errorf("google.DefaultClient: %w", err)
	}
	// Create the jobs service client.
	service, err := talent.New(client)
	if err != nil {
		return nil, fmt.Errorf("talent.New: %w", err)
	}

	job, err := service.Projects.Jobs.Get(jobName).Do()
	if err != nil {
		return nil, fmt.Errorf("Failed to get job %s: %w", jobName, err)
	}

	fmt.Fprintf(w, "Job: %q", job.Name)

	return job, err
}

Busca trabajos

Acabas de crear tu primera empresa y tu primer trabajo con Cloud Talent Solution. Ya estás listo para realizar una búsqueda en estos trabajos.

¿Qué sigue?

Obtén más información sobre las empresas.
Obtén más información sobre los trabajos.