Questa pagina è stata tradotta dall'API Cloud Translation.

Creare azienda e job

Questo tutorial è progettato per aiutarti a iniziare a esplorare e sviluppare applicazioni con Cloud Talent Solution. Si presume la conoscenza della programmazione di base, anche se anche senza molte conoscenze di programmazione dovresti essere in grado di seguire. Dopo aver completato 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 la procedura per creare un'applicazione Cloud Talent Solution utilizzando codice Java. Lo scopo di questo articolo non è spiegare le librerie client Java, ma spiegare come effettuare chiamate a Cloud Talent Solution. Le applicazioni in Python e Node.js sono essenzialmente simili. Per eventuali domande, contattaci.

Prima di iniziare

Sei ora in grado di eseguire le seguenti attività:

hai seguito i passaggi per creare e configurare il progetto, come indicato in Prima di iniziare,
configura l'ambiente utilizzando le Credenziali predefinite dell'applicazione.
familiarità di base con la programmazione in Java o Python,
Hai installato l'ultima versione del client Java per le API di Google o del client Python per le API di Google.

Creare una società con offerte di lavoro e cercarle

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 la procedura per cercare offerte di lavoro all'interno dell'azienda in base agli attributi delle offerte e alla query di ricerca. L'API search tenta di restituire le offerte di lavoro più pertinenti alla query di chi cerca un impiego in base ai campi disponibili all'interno di un lavoro (nome dell'azienda, titolo del lavoro, descrizione del lavoro, categorie di lavoro, località del lavoro e così via).

Crea il servizio con le tue credenziali

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

Java

Per saperne di più sull'installazione e sulla creazione di un client 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 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 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 della tua applicazione. La richiesta OAuth 2.0 viene inviata quando viene effettuata una chiamata API. Il token di autenticazione generato utilizzando la procedura descritta sopra ha in genere una data di scadenza di 1 ora, dopodiché riceverai un messaggio di errore se provi a utilizzarlo. La libreria GoogleCredential si occupa di "aggiornare" automaticamente il token, il che significa semplicemente ottenere un nuovo token di accesso.

Creare un'azienda

Un'azienda è un'entità associata a un insieme di offerte di lavoro. Devi creare l'azienda prima di poter pubblicare offerte di lavoro su Cloud Talent Solution per l'azienda in questione. Puoi inviare qualsiasi stringa di testo libero come externalId durante la creazione della società. 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 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 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 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
}

Recupera azienda

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

Java

Per saperne di più sull'installazione e sulla creazione di un client 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 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 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, nonché il companyName dell'azienda a cui vuoi associarlo, che hai specificato quando hai creato la risorsa dell'azienda.

L'oggetto dati con i dati del job compilati viene inviato all'endpoint Cloud Talent Solution tramite una richiesta POST. Tieni presente che il campo name non deve essere impostato nella richiesta iniziale poiché è un campo "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 Librerie client di Cloud Talent Solution.

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

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

Il seguente codice 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 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 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 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 ulteriori informazioni, visita la pagina locations.

Cloud Talent Solution ha diversi campi associati a un job che sono integrati nello schema dell'API. Tuttavia, potresti avere ancora alcuni campi che non fanno parte dei campi predefiniti. Sebbene sia consigliabile 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 job. Questi possono essere filtrabili o non filtrabili. Per ulteriori informazioni, consulta 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 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 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 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
}

Recuperare il job

Puoi verificare che il job sia stato creato utilizzando l'operazione GET per recuperare i dettagli del job. Tieni presente che potrebbero essere necessari alcuni minuti prima che il job diventi disponibile, in base al volume corrente 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 il job name inserito in precedenza restituito dalla richiesta di creazione originale, come parametro URL.

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 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 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 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 puoi cercare per eseguire una ricerca in questi job.

Passaggi successivi

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