Crear una empresa y un empleo

Crear una empresa y un empleo

Este tutorial está diseñado para que empieces a explorar y desarrollar aplicaciones con Cloud Talent Solution. Se presupone que tienes conocimientos básicos de programación, aunque deberías poder seguir el curso incluso sin tener muchos conocimientos de programación. Después de completar este tutorial, deberías poder usar la documentación de referencia de Cloud Talent Solution para crear tus propias aplicaciones básicas.

En este tutorial se explica cómo usar una aplicación de Cloud Talent Solution con código Java. El objetivo de este artículo no es explicar las bibliotecas de cliente de Java, sino cómo hacer llamadas a Cloud Talent Solution. Las aplicaciones en Python y Node.js son esencialmente similares. No dudes en ponerte en contacto con nosotros si tienes alguna pregunta.

Antes de empezar

Tienes lo siguiente:

• Ha seguido los pasos para crear y configurar su proyecto, tal como se indica en la sección Antes de empezar.
• Configura tu entorno con las credenciales predeterminadas de la aplicación.
• Conocimientos básicos de programación en Java o Python.
• Haber instalado el cliente de la API de Google para Java o el cliente de la API de Google para Python más recientes.

Crear una empresa con empleos y buscar esos empleos

En este tutorial se explica cómo usar una aplicación básica de Cloud Talent Solution y se muestra cómo crear un solo empleo que se asocie a una empresa. En el siguiente tutorial se explica cómo buscar trabajos dentro de la empresa en función de los atributos de los trabajos y de la consulta de búsqueda. La API search intenta devolver los empleos más relevantes para la consulta de un candidato en función de los campos disponibles en un empleo (nombre de la empresa, puesto, descripción, categorías, ubicación, etc.).

Nota: Para copiar el código en el portapapeles, coloca el cursor sobre el icono de copiar del fragmento de código y haz clic. Copia este código en un archivo de tu directorio de desarrollo.

Crear un servicio con tus credenciales

Crea el servicio con el archivo de credenciales JSON que descargaste en la sección Antes de empezar:

Java

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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 de cliente con la información de las credenciales de tu aplicación. La solicitud de OAuth 2.0 se envía cuando se hace una llamada a la API. El token de autenticación generado mediante el proceso anterior suele tener una fecha de vencimiento de 1 hora. Después de ese tiempo, se producirá un error si intentas usarlo. La biblioteca GoogleCredential se encarga de "actualizar" automáticamente el token, lo que significa obtener un nuevo token de acceso.

Crear empresa

Una empresa es una entidad asociada a un conjunto de anuncios de empleo. Debes crear la empresa antes de poder publicar empleos en Cloud Talent Solution para esa empresa. Puedes enviar cualquier cadena de formato libre como externalId al crear la empresa. Esto significa que puedes usar la clave principal de tu base de datos (si tienes una) al crear una empresa y hacer referencia a ella.

Java

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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
}

Nota: Las llamadas de creación de Cloud Talent Solution devuelven un nombre único para cada empresa o empleo. Almacena estos nombres, ya que se usan para actualizar, eliminar o hacer referencia a empresas o trabajos.

Get company

Para consultar el estado actual de una empresa, envía una solicitud GET junto con el name de la empresa asignado por nuestro backend.

Java

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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 tarea

Para publicar un nuevo empleo, debes proporcionar todos los campos obligatorios sobre el nuevo empleo, así como el companyName de la empresa a la que quieras asociar este empleo, que especificaste al crear el recurso de empresa.

El objeto de datos con los datos de la oferta de empleo se envía al endpoint de Cloud Talent Solution mediante una solicitud POST. Ten en cuenta que el campo name no debe definirse en la solicitud inicial, ya que es un campo de solo salida de la API createJob y forma parte de la respuesta de la API cuando el servidor crea una nueva entidad de trabajo. El endpoint de la API para interactuar con el recurso de ofertas de empleo se especifica en el documento de bibliotecas de cliente de Cloud Talent Solution.

La respuesta a la solicitud es un objeto de la nueva oferta de empleo, que debe incluir un name que represente la oferta de forma única. El name se usa cuando es necesario actualizar o eliminar la publicación. Te recomendamos que almacenes name y lo asignes a tu propio ID único del trabajo.

El servidor devuelve un error si intentas insertar un trabajo cuando ya existe otro en el sistema con el mismo companyName, requisitionId y languageCode para la misma empresa.

El siguiente código crea un trabajo con los campos obligatorios de la empresa especificada en el campo companyName.

Java

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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 te permite crear empleos específicos para una ubicación. Consulta locations para obtener más información.

Cloud Talent Solution tiene varios campos asociados a un empleo que están integrados en el esquema de la API. Sin embargo, es posible que aún tengas algunos campos que no formen parte de los campos predefinidos. Aunque se recomienda que todos los clientes de Cloud Talent Solution usen siempre los campos predefinidos cuando sea posible, Cloud Talent Solution también proporciona algunos customAttributes para un empleo. Pueden ser filtrables o no filtrables. 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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
}

Recuperar tarea

Para confirmar que se ha creado el trabajo, usa la operación GET para obtener los detalles del trabajo. Ten en cuenta que el trabajo puede tardar un par de minutos en estar disponible, en función del volumen de trabajos que se estén creando en Cloud Talent Solution.

Para obtener los detalles de un empleo insertado anteriormente, envía una solicitud GET a Cloud Talent Solution. El URI debe incluir el trabajo name insertado anteriormente, que se devuelve en la solicitud de creación original, como parámetro de URL.

En el siguiente ejemplo se usa una operación GET para obtener los detalles de un trabajo con un name determinado:

Java

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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

Para obtener más información sobre cómo instalar y crear un cliente de Cloud Talent Solution, consulta las bibliotecas de 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
}

Buscar empleos

Has creado tu primera empresa y tu primer empleo con Cloud Talent Solution. Ahora puedes buscar para hacer una búsqueda en estos empleos.

Siguientes pasos

• Consulta más información sobre las empresas.
• Más información sobre los trabajos