שליחת שאילתות ל-Job Search API עם Google Cloud

ב-Codelab הזה תלמדו איך לשפר את חיפוש המשרות והכשרונות בארגון שלכם באמצעות Cloud Talent Solution API (CTS). באמצעות CTS אפשר להוסיף את העוצמה של הלמידה החישובית לחוויה בחיפוש עבודה!

מה תלמדו

  • הפעלת CTS בפרויקט שלך ב-Google Cloud
  • שאילתה לגבי משרות פתוחות באמצעות Job Search API

מה צריך?

  • פרויקט ב-Google Cloud עם חיוב שכבר הוגדר (אם עדיין לא הגדרתם פרויקט, יוצרים פרויקט).
  • כשעה

איך תשתמשו במדריך הזה?

לקרוא אותו בלבד לקרוא אותו ולהשלים את התרגילים

איך היית מדרג את החוויה הקודמת שלך ב-Google Cloud Platform?

מתחילים מומחים מומחים

המדריך הזה נועד להפעלה מלאה ב-Google Cloud Platform. אין צורך להוריד את תחנת העבודה.

הפעלת Cloud Talent Solutions API

פותחים את האפליקציה ב-Cloud Console ולוחצים על תפריט ההמבורגר בפינה הימנית העליונה. מעיינים בתפריטים אל פתרון כשרות -> סקירה כללית.

מאחר שמדובר בפרויקט חדש, נפנה אותך למסך חדש שבו נבקש ממך להפעיל את ה-API. לוחצים על 'הפעלה' ומחכים כמה דקות עד שה-API יופעל בפרויקט הזה.

הפעלה של רישום נתונים

עכשיו חוזרים לדף הסקירה הכללית מהעבר. תופיע תיבת דו-שיח חדשה שבה תתבקשו להפעיל את רישום הנתונים. לשם כך, צריך לדעת שה-Job Search API מופעל באמצעות מודל למידה חישובית שזקוקים לנתונים. כחלק מהשילוב, תהיה לך אפשרות לשלוח אירועים ממשתמשים שרוצים לאמן את המודלים האלה עוד. כשהאפשרות הזו מיושמת באמצעות קוד, אפשר לציין איזה מידע יישלח.

נבחן לעומק את האירועים האלה ואיך אפשר לשלוח אותם מאוחר יותר, אבל המודלים שהוכשרו מראש יפעלו היטב. הפעילו את רישום הנתונים ביומן, ולאחר מכן לחצו על &מירכאות;חיבורי חשבון לשירות; בסרגל הניווט הימני בתיבת דו-שיח זו.

הגדרת חשבון שירות

כששולחים בקשות API, צריך לשלוח אותן בשם חשבון מאומת בפועל. לפי השיטות המומלצות של Google Cloud Platform, מומלץ להגדיר חשבון שירות לשם כך. כדאי לחשוב על חשבונות שירות כדי להגדיר משתמשים מאומתים שיש להם הרשאות מוגבלות. זה יעזור לך ליצור מערכת עצמאית ומאובטחת.

לדוגמה, אנחנו צריכים חשבון שירות כדי להשתמש ב-Job Search API. אפשר ליצור אחת! אחרי שלוחצים על ' "חיבורי חשבון שירות' ;& ;, לוחצים על &ציטוט; ניהול חשבונות שירות &&; בחלק העליון של הדף, ואז על " "יצירת חשבון שירות". מספקים הרשאות קריאה/כתיבה באמצעות "Job Editor" בקטע "Cloud Talt Solution" בתפריט הימני. אפשר גם להגדיר חשבון שירות עם "JobView" כדי שתהיה לו גישה לקריאה בלבד.

בשלב הבא, תשאלו אם אתם רוצים להעניק למשתמשים גישה לחשבון השירות הזה. ניתן לדלג על השלב הזה, אבל חשוב ללחוץ על "+ יצירת מפתח&ציטוט; בחלק התחתון של המסך. מתבצעת הורדה אוטומטית של קובץ פרטי הכניסה של JSON. יש לאחסן את הקובץ הזה בשרת שלך, הקוד שיכתוב בקטע מאוחר יותר ישמש אותו לאימות.

הגדרה של משתני סביבה

לנוחיותכם, נשתמש ב-Google Cloud Shell. אם ברצונך לעשות זאת מסביבת הפיתוח שלך, נהדר! מקפידים להתקין את Google Cloud SDK ואת ספריות הלקוחות בשפה שבחרתם (הקוד הזה ישתמש ב-Python). ב-Cloud Shell כבר יותקנו ספריות של לקוחות בענן. נכון?

כדי להריץ קוד באמצעות הספריות, צריך לוודא ששני משתני סביבה מוגדרים: אחד כדי לציין את מזהה הפרויקט, והשני כדי לציין את קובץ המפתח של חשבון השירות. כדאי להגדיר אותם.

בפרויקט, לוחצים על הסמל ">_" בפינה השמאלית העליונה של מסוף האינטרנט כדי לפתוח מעטפת בענן. צריך להוסיף את משתני הסביבה הבאים כדי לציין את מזהה הפרויקט ולהגדיר נתיב לקובץ של מפתח ה-json:

export GOOGLE_CLOUD_PROJECT="your-project-id"
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json"

לפני ביצוע חיפושים אחר משרות במערכת, נצטרך לוודא שיש כמה כאלה בפועל.

אם אתם רוצים ללמוד איך להוסיף חברות ועבודות באמצעות ה-API, מצוין! קדימה, ובצעו את מעבדת הקוד בנושא הזה בדיוק. אחרת, קטע זה כולל הנחיות מפורטות.

פותחים את עורך הקוד ב-Cloud Shell

ב-Google Cloud Console, פותחים את Cloud Shell באמצעות סמל Cloud Cloud בצד שמאל למעלה.

בפינה השמאלית העליונה של קונכיה ענן תוצג סדרה של סמלים. לוחצים על File -> Update Code Editor, כפי שמוצג כאן:

יוצרים חברות ומשרות מסוימות.

משתמשים באפשרות קובץ -> קובץ חדש כדי ליצור קובץ מקור חדש, וממלאים אותו בתוכן שבהמשך. קוראים לו create_some_jobs.py.

חשוב לשים לב שהשימוש ב-API ליצירת חברות & משרות אינו במסגרת ההיקף של שיעור Lab זה. ב-codelab הקודם, "Job Search API&quot, מוסבר איך. הקוד הבא יוצר רק מספר משימות במערכת, כדי שנוכל לנסות תכונות שונות של ה-API של החיפוש ולראות אילו תוצאות מופיעות.

create_some_jobs.py

import os

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

# Build the service object, passing in the api name and api version
client_service = build('jobs', 'v3')


project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']


def create_company(request):
    # This is the API call that actually creates the new company.
    result = client_service.projects().companies().create(
        parent=project_id, body=request).execute()
    return result


def create_job(request):
    # The actual API call happens here.
    result = client_service.projects().jobs().create(
        parent=project_id, body=request).execute()
    print('Job created: %s' % result)
    return result


def create_foo():
    foocorp_company_request = {
        "company": {
            'display_name': "FooCorp",
            'external_id': "foo2_llc"
        }
    }

    result_company = create_company(foocorp_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Senior Software Engineer',
        'addresses': ["Mountain View, CA"],

        'description':
        """Experienced software engineer required for full-time position.
        Leadership ability and ability to thrive in highly competitive environment a must.
        <p />Ignore postings from that "Bar" company, their microkitchen is terrible.  Join Team Foo!""",
        'requisition_id': 'foo_swe',
        'application_info': {
            'uris': ['http://www.example.com/foo/software-engineer-application'],
            'emails': ['apply@example.com']
        }
    }
    request = {'job': job}
    result_job = create_job(request)


def create_horsehub():
    horsehub_company_request = {
        "company": {
            'display_name': "Horse Hub",
            'external_id': "horsies_llc"
        }
    }

    result_company = create_company(horsehub_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Junior Software Engineer',
        'description':
        """Hiring entry level software engineer required for full-time position.
        Must be passionate about industry intersection of horses and technology.
        Ability to intelligently discuss the equine singularity a major bonus.
        <p />C'mon bub! Join Horse Hub!""",
        'requisition_id': 'hh_swe',
        'application_info': {
            'uris': ['http://www.example.com/foo/software-engineer-horsehub'],
            'emails': ['apply-horsehub@example.com']
        }
    }
    request = {'job': job}
    result_job = create_job(request)


def create_tandem():
    tandem_company_request = {
        "company": {
            'display_name': "Tandem",
            'external_id': "tandem"
        }
    }

    result_company = create_company(tandem_company_request)
    company_name = result_company.get('name')

    job = {
        'company_name': company_name,
        'title': 'Test Engineer',
        'description':
        """Hiring Test Engineer for full-time position with Tandem.  Must be detail oriented
        and (obviously) comfortable with pair programming.  Will be working with team of Software Engineers.
        <p />Join Tandem today!""",
        'requisition_id': 'tandem_te',
        'application_info': {
            'uris': ['http://www.example.com/tandem/test-engineer'],
            'emails': ['apply-tandem-test@example.com']
        },
        'promotionValue': 1
    }
    request = {'job': job}
    result_job = create_job(request)
    job['requisition_id'] = 'a_tandem_te'
    result_job = create_job(request)


try:
    create_foo()
    create_horsehub()
    create_tandem()

except Error as e:
    print('Got exception while creating company')
    raise e

מריצים את הקוד שלמעלה מהמסוף.

$ python create_some_jobs.py
Job created:
(Lots of output here)

בכל חיפוש, צריך לספק שני אובייקטים: Request ו-RequestMetadata.

תחילה נתמקד ב-RequestMetadata

האובייקט RequestRequestMetadata מספק מידע על המשתמש שמבצע את בקשת החיפוש. חשוב לספק את הפרטים האלה כדי להבטיח חוויית משתמש עקבית וגם כדי לאמן טוב יותר את המודלים של הלמידה החישובית.

ארבעת המאפיינים הבאים מגדירים את אובייקט הבקשה:

  • domain (חובה) הדומיין שבו מתארח החיפוש, למשל foo.com.
  • sessionId (חובה) – מחרוזת מזהה ייחודית לסשן. סשן מוגדר כמשך האינטראקציה של משתמש קצה עם השירות במשך תקופת זמן מסוימת.
  • userId (חובה) מחרוזת ייחודית של מזהה המייצגת את המשתמש.
  • deviceInfo (אופציונלי) הוא אופציונלי וכולל את המזהה וסוג המכשיר, כך שתוכלו להבחין בין חיפוש באינטרנט לבין חיפוש באפליקציה, לדוגמה.

אפשר למצוא גם את רשימת השדות המלאה, לצד מידע על סוג ותיאור, בתיעוד של RequestMetadata

השלבים המינימליים לביצוע חיפוש הם:

  1. הגדרת אובייקט RequestMetadata
  2. שליחת הבקשה למטא-נתונים אלה והוספתה לאובייקט "request"
  3. ביצוע חיפוש ב-Job API באמצעות הבקשה הזו כהגדרה של השאילתה שלנו
  4. מעיינים בתוצאות.

בואו נראה איך זה נראה. פותחים קובץ חדש, search_jobs.py ומדביקים את הפרטים הבאים.

search_jobs.py

import os

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

client_service = build('jobs', 'v3')
project_id = 'projects/' + os.environ['GOOGLE_CLOUD_PROJECT']

# 1) Define RequestMetadata object
request_metadata = {
    'domain':     'example.com',
    'session_id': 'a5ed434a3f5089b489576cceab824f25',
    'user_id':    '426e428fb99b609d203c0cdb6af3ba36',
}

try:
    # 2) Throw RequestMetadata object in a request
    request = {
        'request_metadata': request_metadata,
    }

    # 3) Make the API call
    response = client_service.projects().jobs().search(
        parent=project_id, body=request).execute()

    # 4) Inspect the results
    if response.get('matchingJobs') is not None:
        print('Search Results:')
        for job in response.get('matchingJobs'):
            print('%s: %s' % (job.get('job').get('title'),
                                job.get('searchTextSnippet')))
    else:
        print('No Job Results')

except Error as e:
    # Alternate 3) or 4) Surface error if things don't work.
    print('Got exception while searching')
    raise e

מנסים להריץ את "search"

$ python search_jobs.py
Search Results:
Junior Software Engineer: None
Senior Software Engineer: None
Test Engineer: None
Test Engineer: None

הוא החזיר כל עבודה במערכת.

למה?

כיוון שעדיין לא ציינת פרמטרים לחיפוש! אבל איך תוכלו לעשות זאת? אם רק הקטע הבא עוסק בנושא שימושי ולא הכרחי לחיפוש במסד נתונים. משהו כמו...

הוספת אובייקט JobQuery עם פרמטרים של חיפוש

מבחינה טכנית, בקשת המטא-נתונים היא שדה הבקשה היחיד הנדרש, אך סביר יותר להניח שנחפש משהו כזה כדי שנכלול גם JobQuery. ה-JobQuery יכולה להיות אובייקט פשוט למדי, עם מחרוזת שאילתה של מונחי החיפוש בפועל ומסננים שונים שיעזרו לצמצם את העבודות שהוחזרו. לדוגמה, אפשר להחזיר רק עבודות מחברה מסוימת או לסנן לפי סוגי תעסוקה. בינתיים, אנחנו נשמור על מחרוזת השאילתה, אבל למידע נוסף על המסננים הזמינים בתיעוד של JobQuery

משנים את הקוד בעבר כך שיכלול JobQuery, ומוסיפים אותו לבקשה הקיימת.

search_jobs.py

...
# Create a job query object, which is just a key/value pair keyed on "query"
job_query = {'query': 'horses'}
...
    # Update the request to include the job_query field.
    request = {
        'request_metadata': request_metadata,
        'job_query': job_query
    }
 ...

לאחר מכן מריצים את החיפוש שוב.

$ python search_jobs.py
Search Results:
Junior Software Engineer: Hiring entry level software engineer required for full-time position. Must be
passionate about industry intersection of <b>horses</b> and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

טובות יותר! עדיף בכמה דרכים. נפרט את מה שקרה:

  • ה-API של החיפוש קיבל את פרמטר השאילתה והחזיר רק תוצאה תואמת
  • התוצאה שהוחזרה כוללת קטע טקסט בפורמט HTML עם מונח החיפוש התואם מודגש, שקל להציג אותו ברשימת תוצאות החיפוש.
  • הוספת שאילתת חיפוש הייתה רק 2 שורות קוד נוספות.

בשלב זה יש לך חיפוש בסיסי של עבודה. ניתן להריץ שאילתות מול מסד נתונים של משימות ולאחזר תוצאות. עם זאת, יש עוד המון דברים מדהימים.

הגבלת כמות הנתונים שמוחזרות באמצעות WorkView

תוכלו גם לציין נכס WorkView, שהוא ENUM שמצהיר כמה מידע תרצו לקבל עם בקשת החיפוש. JOB_VIEW_FULL מספק לך את כל המידע על כל תוצאת משרה, אבל כדאי לשמור כמה בייטים ולבחור אפשרות אחרת שמחזירה פחות שדות. בחרו באפשרות המתאימה ביותר לפלטפורמה שאתם עובדים עליה. הערכים האפשריים (על סמך מסמכי התיעוד של JobView) הם:

  • JOB_VIEW_UNSPECIFIED – ברירת מחדל.
  • JOB_VIEW_ID_ONLY - מכיל רק את שם המשרה, מזהה הביקוש וקוד השפה.
  • JOB_VIEW_MINIMAL – כל הפריטים בתצוגה ID_ONLY, וגם שם, שם חברה ומיקומים.
  • JOB_VIEW_small – כל מה שנמצא בתצוגה של MINIMAL, וגם הרשאות גישה ותיאור של משימה.
  • JOB_VIEW_FULL – כל המאפיינים הזמינים.

כדי לקבל ניתוח מעמיק יותר של השדות הזמינים, ניתן לעיין בתיעוד של משרה, האובייקט שהוחזר בתוצאות שאילתת חיפוש. בהמשך יש דוגמה לציון ה-JobView באובייקט הבקשה.

    # What your request object looks like with a jobView field
    request = {
        'requestMetadata': request_metadata,
        'jobQuery': job_query,
        'jobView' : 'JOB_VIEW_FULL'
    }

כאן אנו מגדירים את הפרמטר JOB_VIEW_FULL למטרות קוד ה-Lab הזה, מכיוון שמספר המשרות בשאילתות חיפוש (ומספר המשתמשים בו-זמנית) די נמוך, והוא מאפשר לנו לבדוק בקלות את השדות השונים הזמינים. בסביבת הייצור, מומלץ להשתמש ב-JobView עם מטען ייעודי (payload) קל יותר בעת יצירת אינדקס של תוצאות חיפוש, כי רוחב הפס יהיה נחוץ פחות.

עימוד

מאחר שניתן לקבל הרבה תוצאות, גם העימוד בממשק העימוד מאפשר לעבוד עם ממשק העימוד. אנחנו ממליצים שהגודל של הדף יהיה עד 20 או פחות כדי להימנע מבעיות בזמן האחזור, ולהשתמש תמיד בעימוד דרך ה-API, במקום לטעון בכל התוצאות. תקבלו NextPageToken בתגובה אם יש משרות נוספות כך שתוכלו להעביר אותן לשאילתת החיפוש הבאה של הדף.

שוב, התאמה זו לתוצאות החיפוש מתבצעת על ידי הוספת שדה אחד לבקשה, המציין כמה תוצאות חיפוש ברצונך לקבל בכל דף.

    request = {
        'requestMetadata': request_metadata,
        'jobQuery': job_query,
        'jobView' : 'JOB_VIEW_FULL',
        'pageSize': 1
    }

כדאי לנסות להפעיל את הסקריפט search_jobs כשהדף מוגדר כ-1. אם תפעילו את התוצאה הזו, תקבלו רק תוצאת חיפוש אחת. אבל מסד הנתונים שלך מכיל יותר מפרופיל עבודה אחד. איך מקבלים את השאר?

במקרים שבהם יהיו יותר תוצאות מהתגובה הנוכחית, יופיע שדה NextPageToken בתגובה. יש להזין את הערך הזה, להחזיר אותו לבקשה הקיימת בשם pageToken ולהפעיל שוב את החיפוש. הדוגמה הבאה ממחישה כיצד לעשות זאת.

    if "nextPageToken" in response:
        request["pageToken"] = response.get('nextPageToken')
        response = client_service.projects().jobs().search(
            parent=project_id, body=request).execute()
        for job in response.get('matchingJobs'):
            print('%s: %s' % (job.get('job').get('title'),
                                job.get('searchTextSnippet')))

בדיקה אוטומטית של השאילתה

בדיקת האיות מובנית ב-API – כך שאם מחפש המשרה שלכם יחפש את המילה "manaer", התוצאות יוחזרו לרישומים עם המילה "manager"

תכונה זו מופעלת כברירת מחדל. אם ברצונך להשבית את השדה, יש להוסיף את השדה DisableSpellCheck אל JobQuery ולהגדיר אותו כ-true.

search_jobs.py

job_query = {
   'query': "Enginer",
   'disableSpellCheck': "true"
}

כדאי לנסות להפעיל את זה. כשסימן זה חסר, "Engine&&; יחזיר תוצאות עם המחרוזת "Engine" . כשבדיקת האיות מושבתת, אותה שאילתה תחזיר 0 תוצאות.

בשלב הבא, נסתכל על דרכים לשינוי הרלוונטיות של תוצאות החיפוש.

באמצעות Google Cloud Talent Solution Job Search API נעשה שימוש בלמידה חישובית (ML) כדי לקבוע את מידת הרלוונטיות של משרות פנויות כשמשתמש מחפש משרות.

למשרות ולחברות יש כמה נכסים שהמודלים של הלמידה החישובית מפנים אליהם כדי לקבוע את הרלוונטיות של תוצאות החיפוש. תוכלו להשפיע על הרלוונטיות באופן משמעותי על ידי ציון מידע נוסף או שימוש בפרטים כמו משרות מומלצות. כמובן שמידת הרלוונטיות של תוצאות החיפוש יכולה להיות קשה למדידה, במיוחד מאחר שדברים שונים רלוונטיים לאנשים שונים. ה-Job Search API משתמש באלגוריתם המבוסס על מספר אותות מנתוני המשרה. בואו נראה איך חלק מהאותות האלה משפיעים על תוצאות החיפוש.

המדד 'משרות מומלצות' מאפשר לכם להשפיע על המשתמשים שלכם&33; תוצאות החיפוש על ידי דירוג המשרות לפי ערך המבצע, ולא רק לפי הרלוונטיות שלהן. כשמריצים חיפוש של משרות מומלצות, היא מחזירה רק משרות רלוונטיות עם ערך של קידום מכירות שהוקצה.

משרות מומלצות שימושיות במקרים שבהם אתם רוצים לתת חסות למשרות נפרדות באינדקס שלכם. לדוגמה, אתר קריירה שמקדם משרות קריטיות בתחום העסק יכול להשתמש בחיפוש 'משרות מומלצות' כדי להחזיר למשרות פנויות רק הצעות ממומנות.

כדי להגדיר משרה כ-"featured" נעשה שימוש בשדה promotionValue בהגדרת המשרה כשיוצרים או מעדכנים משרה. בסקריפט create_some_jobs.py שבו השתמשנו קודם לכן ב-codelab זה, אחת המשרות נוצרה באמצעות ערך של קידום מכירות. הנה שוב קטע הטקסט שהשורה הרלוונטית מוקפת בתגובות:

create_some_jobs.py

   job = {
       'company_name': company_name,
       'title': 'Test Engineer',
       'description':
       """Hiring Test engineer for full-time position with Tandem.  Must be detail oriented
       and (obviously) comfortable with pair programming..
       <p />Join Tandem today!""",
       'requisition_id': 'tandem_te',
       'application_info': {
           'uris': ['http://www.example.com/tandem/test-engineer'],
           'emails': ['apply-tandem-test@example.com']
       },
       # Down here vvvvv
       'promotionValue': 1
       # Up there ^^^^^
   }

ערך המבצע יכול להיות כל מספר שלם בין 1 ל-10. כשמשנים את מצב החיפוש ל-FEATURED_JOB_SEARCH (ראו איך זה עובד), תוצאות החיפוש יושפעו בשתי דרכים:

  • יוצגו רק משרות עם promotionalValue > 0
  • המשרות ימוינו בסדר יורד של promotionalValue. משרות עם אותו promotionalValue ימוינו לפי רלוונטיות (כפי שנקבע על ידי אלגוריתם החיפוש).
   request = {
       'searchMode': 'FEATURED_JOB_SEARCH',
       'requestMetadata': request_metadata,
       'jobQuery': job_query,
       'jobView' : 'JOB_VIEW_FULL'
   }

עדכן את הבקשה שלך כדי להגדיר את מצב החיפוש ל-FEATURED_JOB_SEARCH. לאחר מכן, הפעילו את הקוד ואתם אמורים לראות פלט דומה למטה:

$ $ python search_jobs.py
Search Results:
Test Engineer: Hiring Test <b>engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming.. Join Tandem today!

העבודה עם promotionValue שמוגדרת באופן מפורש מעל 0 היא התוצאה היחידה שהוחזרה.

מיקום גיאוגרפי

אחד מהמאפיינים החשובים ביותר הוא מיקום גיאוגרפי. גם לחברות וגם למשרות יש נכסי מיקום, אבל מיקום המשרה ישמש מעל מיקום החברה כשמשתמש יחפש. עליכם להשתמש בשדה הכתובת הספציפי של משרות וחברות. כך, ה-API יוכל להשתמש במיקום הגיאוגרפי כדי להחזיר את המשרות הרלוונטיות ביותר לחיפוש. אם מישהו מחפש "סן פרנסיסקו" הוא בוודאי רוצה לראות בעיקר עבודות בסן פרנסיסקו ובסביבתה.

במשרות לדוגמה שלנו, במיקום של מהנדס תוכנה בכיר ב-FooCorp יש שדה מיקום המוגדר ל-Mountain View, קליפורניה. הקוד שמבצע את הפעולה הזו (אם אינכם מרגישים בנוח לחזור לדף ולבצע חיפוש) נראה כך:

create_some_jobs.py (כאשר המיקום מוגדר ב-FooCorp)

...
    job = {
        'company_name': company_name,
        'title': 'Senior Software Engineer',
        'addresses': ["Mountain View, CA"],
...

כדי לקבל את התוצאות הטובות ביותר, מומלץ להזין שם עירוני, אבל מומלץ להזין כתובת מלאה.

למרות שזה אופציונלי מבחינה טכנית, הוספת מיקום מאפשרת הרבה פונקציונליות שימושית למי מחפש העבודה. מערכת CTS תמיר את הכתובת הזו לקווי אורך ורוחב, ותשתמש בה כאות חיפוש. לדוגמה, כך אפשר לשנות את השאילתה של JobQuery לחיפוש משרה במשרות בפאלו אלטו, עם מרחק מקסימלי של 16 ק"מ:

search_jobs.py (חיפוש עבודות ב-Pal class Palo Alto)

...
location_filter = {
   'address': 'Palo Alto',
   'distance_in_miles': 10,
   }

job_query = {
   'location_filters': [location_filter],
   'query': "Engineer",
}
...

מריצים את הקוד הזה. חשוב לזכור שבמקום כלשהו בקוד של יצירת המשרה, הזכרנו פעם את פאלו אלטו. אין תיאור תפקיד, שם החברה, אין שום דבר.

$ python search_jobs.py
Search Results:
Senior Software Engineer: Experienced software <b>engineer</b> required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

הוחזרה תוצאה! מאחר ש-Palo Alto נמצא במרחק 16 ק"מ מהעבודה (16 ק"מ) הגבול הוא הגבול שהגדרת ב-LocationFilters)

יש עוד כמה דברים משעשעים שאפשר לעשות עם המיקום שלא נכלל במעבדה זו. מומלץ לעיין במקורות הבאים:

  • חיפוש מבוסס נסיעה – מחפשים עבודות באזור שהוגדר על ידי זמן הנסיעה לעבודה במקום מרחק. אם אתם חושבים&חושבים, היי, הלוואי שהייתי רואה ש..." כולנו עושים זאת, קוראים. כולנו עושים את זה.
  • חיפוש מרובה מיקומים – כיצד מחפשים עבודות במספר ערים בו-זמנית.

מילות מפתח והרחבה

לכותרת ולתיאור של עבודה יש תפקיד חשוב בקביעה אם היא מתאימה לשאילתת חיפוש, כמובן. אם משרה של "נושא מאסטר" ומתארת בתיאור את המונח "ניהול מפתחי תוכנות", צריך לחפש את &"מנהל פיתוח תוכנה&quot. הקפידו לא להסתבך בקבוצה של מילות מפתח בתיאורי משרות, אחרת עלולות להופיע מספר משרות פחות רלוונטיות.

ל-API יש גם כמה פרמטרים שאפשר להעביר כשמבצעים חיפוש כדי לשלוט טוב יותר בתוצאות. התאמה למילת מפתח מאפשרת לך להפעיל או להשבית אם החיפוש צריך לחפש מילות מפתח מלבד תוצאות החיפוש הרגילות המבוססות על למידה חישובית. כמו כן, פעולה זו תרגיע חלק מהמסננים הספציפיים למיקום. הרחבה תרחיב את היקף החיפוש של הפרמטרים הנתונים כך שתוכלו לקבל תוצאות נוספות לחיפוש.

הנה דוגמה לעשות זאת. תחילה, בלי להפעיל את ההרחבה, מבצעים חיפוש באמצעות מונח השאילתה "Agile". אם השתמשתם בסקריפט שסופק ב-codelab הזה כדי ליצור את המשרות והחברות שלכם, לא יקרה דבר. למה? מפני שהמילה "Agile" לא נמצאת בשום מקום בכרטיסי המוצר. עם זאת, זו מתודולוגיה פופולרית לתכנות, המשויכת למשרות הנדסה.

בואו נרחיב את מילות המפתח ונראה מה ישתנה.

search_jobs.py (עם הרחבה מופעלת)

...
job_query = {
    'query': "Agile",
}

request = {
    'requestMetadata': request_metadata,
    'jobQuery': job_query,
    'jobView' : 'JOB_VIEW_FULL',
    'enableBroadening' : True
}
...

כעת הרץ מחדש את הסקריפט, והפעם תראה כמה תוצאות!

$ python search_jobs.py
Search Results:
Junior Software Engineer: Hiring entry level software engineer required for full-time position. Must be
passionate about industry intersection of horses and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

Senior Software Engineer: Experienced software engineer required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

Test Engineer: Hiring Test engineer for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming.. Join Tandem today!

עכשיו, איך אפשר לדעת שזה לא רק סימון גורף של "החזרת כל הפריטים"? כדאי לנסות להחליף את הביטוי "Agile" בכמה מילים נרדפות, למשל & "sprightly", "dexterous", "lively" או "swift". בכל המקרים לא מופיע שום דבר.

עם זאת, יש אפשרות לאפשר את ההרחבה. בדף השיטות המומלצות לחיפוש עבודה מצוין בבירור ש-"הפעלת הפרמטר הזה מגדילה את מספר תוצאות החיפוש, אבל עשויה להפחית את הרלוונטיות של התוצאות הכוללות". בעיקרון, תכונה זו מסכנת את הוספת הכמות על חשבון האיכות. מצד שני, יכול להיות שהוא יעזור למחפשי העבודה שלכם למצוא משהו שהם פשוט לא ידעו איך לבטא אותו כמו שצריך.

גיוון

לפעמים מוחזרות מספר משרות דומות זו לצד זו בתוצאות החיפוש. מצב כזה יכול להשפיע לרעה על מי שמבקש למצוא עבודה, ולמנוע ממנו לראות את מגוון התוצאות הזמינות.

תכונת הגיוון מתקנת את הבעיה הזו. המשרות מוגדרות כדומות לפי השם, קטגוריות המשרה והמיקומים. לאחר מכן, תוצאות דומות מאוד מקובצות כך שרק משרה אחת מהאשכול תוצג גבוה יותר בתוצאות החיפוש. ייתכן שהבחנתם במונח "ציטוט", למשל, אם קיבלתם תוצאות כמו:

$ python search_jobs.py
Test Engineer ...
Senior Software Engineer ...
Junior Software Engineer ...
Test Engineer ...

למה זה הוזמן כך? טוב, המשרות של מהנדסי התוכנה מגיעות משתי חברות שונות (HorseHub ו-FooCorp) ויש להן תיאורים שונים. שתי המשרות עוסקות בהנדסת תוכנה, אבל הן שונות מספיק כדי להיות קרובים זו לזו בתוצאות.

עם זאת, אם תעיינו ברישומים של &מירכאות, מהנדסי תוכנה, זה למעשה אותו רישום של אותה חברה. מכיוון שהגיוון מופעל כברירת מחדל, הרישום השני של מהנדס הבדיקה נחשב כחשוב פחות (למרות שהוא רלוונטי יותר מבחינה טכנית) מכרטיסי מוצר אחרים שעשויים להיות מעניינים יותר.

ברמת הגיוון יש 3 הגדרות אפשריות, אך אי אפשר לבחור אחת מהן באופן מפורש. אלו הם:

  • DIVERSIFICATION_LEVEL_UNSPECIFIED – המשמעות היא שלא ציינת רמה, והיא צריכה לבצע את הפעולה המוגדרת כברירת המחדל (נכון לעכשיו, ברירת המחדל זהה להתנהגות של SIMPLE)
  • מושבתת - השבתת גיוון – משרות שבדרך כלל יידחפו אל הדף האחרון עקב היו דומות מדי, לא ישנו את המיקום שלהן.
  • SIMPLE – התנהגות מגוונת שמוגדרת כברירת מחדל. רשימת התוצאות מסודרת כך שתוצאות דומות מאוד נדחפות לסוף הדף האחרון של תוצאות החיפוש.

כך עליך להגדיר במפורש את רמת הגיוון בבקשה שלך. כמו ברוב הפעולות האחרות שאנחנו עושים, בהגדרות של מעבדת הקוד הזו, כל מה שאתם צריכים לעשות הוא להתאים את הבקשה שלכם. נסו לבצע את ההגדרות שבהמשך עבור שאילתת העבודה והבקשה שלכם. פעולה זו תשבית את הגיוון והגדרת מונח החיפוש בתור "Engine"

search_jobs.py (רמת גיוון)

job_query = {
    'query': "Engineer",
}

# 2) Throw RequestMetadata object in a request
request = {
    'requestMetadata': request_metadata,
    'jobQuery': job_query,
    'jobView' : 'JOB_VIEW_FULL',
    'diversificationLevel': 'DISABLED'
}

הפעילו את search_jobs.py עכשיו, ואתם תראו סדר שונה מעט – כעת המשרות של מהנדסי הבדיקה קרובות יותר זו לזו.

$python search_jobs.py
Test Engineer: Hiring Test <b>Engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming. Will be working with team of
Software Engineers. Join Tandem today!

Test Engineer: Hiring Test <b>Engineer</b> for full-time position with Tandem. Must be detail oriented
and (obviously) comfortable with pair programming. Will be working with team of
Software Engineers. Join Tandem today!

Software Engineer: Experienced software <b>engineer</b> required for full-time position. Leadership ability
and ability to thrive in highly competitive environment a must. Ignore postings
from that &quot;Bar&quot; company, their microkitchen&nbsp;...

Software Engineer: Hiring entry level software <b>engineer</b> required for full-time position. Must be
passionate about industry intersection of horses and technology. Ability to
intelligently discuss the equine singularity a major&nbsp;...

למדת באופן רשמי כיצד לשלוח שאילתות למשרות באמצעות ה-Job Search API.

מה כללנו?

  • הגדרת הפרויקט שלך ב-Cloud
  • הגדרת סביבת הפיתוח
  • שליחת שאילתות לגבי משרות
  • הוספת אובייקט JobQuery עם פרמטרים של חיפוש
  • הגבלת כמות הנתונים שמוחזרות באמצעות WorkView
  • עימוד
  • בדיקת איות אוטומטית של השאילתה
  • משרות מומלצות
  • התאמה לרלוונטיות של החיפוש
  • מיקום גיאוגרפי
  • מילות מפתח והרחבה
  • גיוון

מידע נוסף