Crea un'azienda e un lavoro in Talent Solution

Crea un'azienda e un lavoro in Talent Solution

Questo tutorial è pensato per aiutarti a iniziare a esplorare e sviluppare applicazioni con Cloud Talent Solution. Si presume avere familiarità con la programmazione di base, anche se non hai molta familiarità con la programmazione devi essere in grado di seguirli. Dopo aver seguito questo tutorial, dovresti essere in grado di utilizzare la documentazione di riferimento di Cloud Talent Solution per creare le tue applicazioni di base.

Questo tutorial illustra un'applicazione di Cloud Talent Solution che utilizza il codice Java. Lo scopo qui non è spiegare le librerie client di Java, ma spiegare come effettuare chiamate a Cloud Talent Solution. Le applicazioni in Python e Node.js sono sostanzialmente simili. Per eventuali domande, contattaci.

Prima di iniziare

Sei ora in grado di eseguire le seguenti attività:

• seguito i passaggi per creare e configurare il progetto, come indicato nella sezione Prima di iniziare,
• configurare il tuo ambiente utilizzando Credenziali predefinite dell'applicazione,
• una certa familiarità con la programmazione Java o Python.
• Avere installato la versione più recente del client Java dell'API di Google o del client Python dell'API di Google.

Crea un'azienda con offerte di lavoro e cerca quelle

Questo tutorial illustra un'applicazione di base di Cloud Talent Solution e ti guida nella creazione di un singolo job da associare a un'azienda. Il prossimo tutorial illustra i passaggi per cercare offerte di lavoro all'interno dell'azienda in base agli attributi delle offerte di lavoro e alla query di ricerca. L'API search tenta di restituire i job più pertinenti alla query di una persona in cerca di lavoro in base ai campi disponibili all'interno di un determinato job (nome dell'azienda, qualifica, descrizione del lavoro, categorie della prestazione, località e così via).

Nota: copia il codice negli appunti passando il mouse sopra l'icona di copia nello snippet di codice e facendo clic. Copia questo codice in un file all'interno della directory di sviluppo.

Crea il servizio con le tue credenziali

Crea il servizio con il file delle credenziali JSON che hai scaricato in Prima di iniziare:

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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)
	}
}

Questo codice configura il servizio client con le informazioni sulle credenziali dell'applicazione. La richiesta OAuth 2.0 viene inviata quando viene effettuata una chiamata API. Il token di autorizzazione generato utilizzando la procedura descritta sopra in genere ha una data di scadenza di un'ora. Trascorso questo periodo, se provi a utilizzarlo verrà visualizzato un errore. La libreria GoogleCredential si occupa di "aggiornare" automaticamente il token, il che significa semplicemente che riceve un nuovo token di accesso.

Crea azienda

Una società è un'entità associata a un insieme di annunci di lavoro. Devi creare l'azienda prima di poter pubblicare offerte di lavoro su Cloud Talent Solution per tale azienda. Puoi inviare qualsiasi stringa in formato libero come externalId durante la creazione dell'azienda. Ciò significa che puoi utilizzare la chiave primaria del tuo database esistente (se ne hai uno) quando crei e fai riferimento a un'azienda.

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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: le chiamate per la creazione di Cloud Talent Solution restituiscono un nome univoco per ogni azienda/lavoro. Memorizza questi nomi quando vengono utilizzati per aggiornare/eliminare/riferire aziende/lavori.

Trova azienda

Puoi leggere lo stato attuale di un'azienda inviando una richiesta GET, insieme a name dell'azienda assegnata dal nostro backend.

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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
}

Crea job

Per pubblicare un nuovo job, devi fornire tutti i campi obbligatori relativi al nuovo job insieme all'companyName dell'azienda a cui vuoi associare il job che hai specificato al momento della creazione della risorsa azienda.

L'oggetto dati con i dati del job inseriti viene inviato all'endpoint Cloud Talent Solution utilizzando una richiesta POST. Tieni presente che il campo name non deve essere impostato nella richiesta iniziale poiché è un campo di solo output dell'API createJob e fa parte della risposta dell'API quando il server crea una nuova entità job. L'endpoint API per interagire con la risorsa job è specificato nel documento sulle librerie client di Cloud Talent Solution.

La risposta alla richiesta è un oggetto della nuova offerta di lavoro; deve includere un'offerta name che rappresenta in modo univoco l'offerta. L'offerta di lavoro name viene utilizzata quando l'offerta deve essere aggiornata o eliminata. Come best practice, archivia questo name e mappalo al tuo ID univoco per il job.

Il server restituisce un errore se tenti di inserire un job quando nel sistema esiste già un altro job con gli stessi companyName, requisitionId e languageCode per la stessa azienda.

Il codice seguente crea un job con solo i campi obbligatori per l'azienda specificata nel campo companyName.

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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 ti consente anche di creare offerte di lavoro specifiche per una località. Per saperne di più, visita la pagina locations.

Cloud Talent Solution ha diversi campi associati a un job integrati nello schema API. Tuttavia, è possibile che alcuni campi non facciano parte dei campi predefiniti. Sebbene sia consigliato che tutti i clienti di Cloud Talent Solution utilizzino sempre i campi predefiniti ove possibile, Cloud Talent Solution fornisce anche alcuni attributi personalizzati per un lavoro. Potrebbero essere filtrabili o non filtrabili. Per saperne di più, consulta la pagina customAttributes.

Il seguente esempio di codice mostra come creare un job con un customAttribute:

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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 job

Puoi confermare che il job sia stato creato utilizzando l'operazione GET per OTTENERE i dettagli del job. Tieni presente che potrebbero essere necessari un paio di minuti prima che il job diventi disponibile, in base al volume attuale di job creati in Cloud Talent Solution.

Puoi recuperare i dettagli di un job inserito in precedenza inviando una richiesta GET a Cloud Talent Solution. L'URI deve includere come parametro URL il job name inserito in precedenza, restituito dalla richiesta di creazione originale.

L'esempio seguente utilizza un'operazione GET per recuperare i dettagli di un job con un determinato name:

Java

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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

Per saperne di più sull'installazione e sulla creazione di un client di Cloud Talent Solution, consulta Librerie client di 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
}

Ricerca lavoro

Hai creato la tua prima azienda e il tuo primo lavoro utilizzando Cloud Talent Solution. Ora sei pronto per eseguire una ricerca per eseguire una ricerca tra queste offerte di lavoro.

Passaggi successivi

• Scopri di più sulle aziende.
• Scopri di più sui job.