en-us	#### Configuring authentication  The **Authentication** tab allows you to configure scenario authentication options. A green dot next to the tab name indicates that some type of HTTP authentication is enabled.  ![](../../assets/en/manual/config/scenario_d.png)  Authentication parameters:  |Parameter|Description| |--|--------| |*Authentication*|Authentication options.<br>**None** - no authentication used.<br>**Basic** - basic authentication is used.<br>**NTLM** - NTLM ([Windows NT LAN Manager)](http://en.wikipedia.org/wiki/NTLM) authentication is used.<br>**Kerberos** - Kerberos authentication is used. See also: [Configuring Kerberos with Zabbix](/manual/appendix/items/kerberos).<br>**Digest** - Digest authentication is used.<br>Selecting an authentication method will provide two additional fields for entering a user name and password.<br>User macros can be used in user and password fields.| |*SSL verify peer*|Mark the checkbox to verify the SSL certificate of the web server.<br>The server certificate will be automatically taken from system-wide certificate authority (CA) location. You can override the location of CA files using Zabbix server or proxy configuration parameter [SSLCALocation](/manual/appendix/config/zabbix_server).<br>This sets the [CURLOPT\_SSL\_VERIFYPEER](http://curl.haxx.se/libcurl/c/CURLOPT_SSL_VERIFYPEER.html) cURL option.| |*SSL verify host*|Mark the checkbox to verify that the *Common Name* field or the *Subject Alternate Name* field of the web server certificate matches.<br>This sets the [CURLOPT\_SSL\_VERIFYHOST](http://curl.haxx.se/libcurl/c/CURLOPT_SSL_VERIFYHOST.html) cURL option.| |*SSL certificate file*|Name of the SSL certificate file used for client authentication. The certificate file must be in PEM^1^ format. If the certificate file contains also the private key, leave the *SSL key file* field empty. If the key is encrypted, specify the password in *SSL key password* field. The directory containing this file is specified by Zabbix server or proxy configuration parameter [SSLCertLocation](/manual/appendix/config/zabbix_server).<br>`HOST.*` macros and user macros can be used in this field.<br>This sets the [CURLOPT\_SSLCERT](http://curl.haxx.se/libcurl/c/CURLOPT_SSLCERT.html) cURL option.| |*SSL key file*|Name of the SSL private key file used for client authentication. The private key file must be in PEM^1^ format. The directory containing this file is specified by Zabbix server or proxy configuration parameter [SSLKeyLocation](/manual/appendix/config/zabbix_server).<br>`HOST.*` macros and user macros can be used in this field.<br>This sets the [CURLOPT\_SSLKEY](http://curl.haxx.se/libcurl/c/CURLOPT_SSLKEY.html) cURL option.| |*SSL key password*|SSL private key file password.<br>User macros can be used in this field.<br>This sets the [CURLOPT\_KEYPASSWD](http://curl.haxx.se/libcurl/c/CURLOPT_KEYPASSWD.html) cURL option.|  ::: noteimportant  \[1\] Zabbix supports certificate and private key files in PEM format only. In case you have your certificate and private key data in PKCS \#12 format file (usually with extension \*.p12 or \*.pfx) you may generate the PEM file from it using the following commands:      openssl pkcs12 -in ssl-cert.p12 -clcerts -nokeys -out ssl-cert.pem     openssl pkcs12 -in ssl-cert.p12 -nocerts -nodes  -out ssl-cert.key   :::  ::: noteclassic  Zabbix server picks up changes in certificates without a restart.  :::  ::: noteclassic  If you have client certificate and private key in a single file just specify it in a "SSL certificate file" field and leave "SSL key file" field empty. The certificate and key must still be in PEM format. Combining certificate and key is easy:      cat client.crt client.key > client.pem   :::
he	#### הגדרת אימות  הכרטיסייה **אימות** מאפשרת לך להגדיר תרחיש אפשרויות אימות. נקודה ירוקה ליד שם הכרטיסייה מציינת זאת סוג כלשהו של אימות HTTP מופעל.  ![](../../assets/en/manual/config/scenario_d.png)  פרמטרי אימות:  |פרמטר|תיאור| |--|--------| |*אימות*|אפשרויות אימות.<br>**ללא** - לא נעשה שימוש באימות.<br>**בסיסי** - נעשה שימוש באימות בסיסי.<br>**NTLM** - NTLM ([Windows NT LAN מנהל)](http://en.wikipedia.org/wiki/NTLM) נעשה שימוש באימות.<br>**Kerberos** - נעשה שימוש באימות Kerberos. ראה גם: [הגדרת Kerberos עם Zabbix](/manual/appendix/items/kerberos).<br>**Digest** - נעשה שימוש באימות Digest.<br>בחירת שיטת אימות תספק שני שדות נוספים להזנת משתמש שם וסיסמה.<br>ניתן להשתמש בפקודות מאקרו של משתמש בשדות משתמש וסיסמה.| |*SSL verify peer*|סמן את תיבת הסימון כדי לאמת את אישור ה-SSL של שרת האינטרנט.<br>אישור השרת יילקח אוטומטית ממיקום רשות האישורים (CA) בכל המערכת. אתה יכול לעקוף את המיקום של קבצי CA באמצעות שרת Zabbix או פרמטר תצורת proxy [SSLCALocation](/manual/appendix/config/zabbix_server).<br>זה מגדיר את ה-[CURLOPT\_SSL\_VERIFYPEER](http://curl.haxx .se/libcurl/c/CURLOPT_SSL_VERIFYPEER.html) אפשרות cURL.| |*SSL verify host*|סמן את תיבת הסימון כדי לוודא שהשדה *Common Name* או השדה *Subject Alternate Name* של תעודת שרת האינטרנט תואמים.<br>זה מגדיר את [CURLOPT\_SSL\_VERIFYHOST](http: //curl.haxx.se/libcurl/c/CURLOPT_SSL_VERIFYHOST.html) אפשרות cURL.| |*קובץ אישור SSL*|שם קובץ אישור ה-SSL המשמש לאימות לקוח. קובץ האישור חייב להיות בפורמט PEM^1^. אם קובץ האישור מכיל גם את המפתח הפרטי, השאר את השדה *קובץ מפתח SSL* ריק. אם המפתח מוצפן, ציין את הסיסמה בשדה *סיסמת מפתח SSL*. הספרייה המכילה קובץ זה מצוינת על ידי פרמטר תצורת שרת Zabbix או פרוקסי [SSLCertLocation](/manual/appendix/config/zabbix_server).<br>`HOST.*` ניתן להשתמש בפקודות מאקרו ופקודות מאקרו משתמש בשדה זה.<br> זה מגדיר את אפשרות ה-cURL [CURLOPT\_SSLCERT](http://curl.haxx.se/libcurl/c/CURLOPT_SSLCERT.html).| |*קובץ מפתח SSL*|שם קובץ המפתח הפרטי SSL המשמש לאימות לקוח. קובץ המפתח הפרטי חייב להיות בפורמט PEM^1^. הספרייה המכילה קובץ זה מצוינת על ידי פרמטר תצורת שרת Zabbix או פרוקסי [SSLKeyLocation](/manual/appendix/config/zabbix_server).<br>'HOST.*' ניתן להשתמש בפקודות מאקרו ופקודות מאקרו משתמש בשדה זה.<br> זה מגדיר את אפשרות ה-cURL [CURLOPT\_SSLKEY](http://curl.haxx.se/libcurl/c/CURLOPT_SSLKEY.html).| |*סיסמת מפתח SSL*|סיסמת קובץ מפתח פרטי SSL.<br>ניתן להשתמש בפקודות מאקרו משתמש בשדה זה.<br>זה מגדיר את ה-[CURLOPT\_KEYPASSWD](http://curl.haxx.se/libcurl/c /CURLOPT_KEYPASSWD.html) אפשרות cURL.|  ::: הערה חשוב   \[1\] Zabbix תומך באישור ובמפתח פרטי קבצים בפורמט PEM בלבד. למקרה שיש לך תעודה ופרטית נתוני מפתח בקובץ בפורמט PKCS \#12 (בדרך כלל עם סיומת \*.p12 או \*.pfx) תוכל ליצור ממנו את קובץ ה-PEM באמצעות הפעולות הבאות פקודות:       openssl pkcs12 -in ssl-cert.p12 -clcerts -nokeys -out ssl-cert.pem      openssl pkcs12 -in ssl-cert.p12 -nocerts -nodes -out ssl-cert.key   :::  ::: noteclassic   שרת Zabbix קולט שינויים בתעודות ללא א איתחול. :::  ::: noteclassic   אם יש לך אישור לקוח ומפתח פרטי ביחיד פשוט ציין אותו בשדה "קובץ אישור SSL" והשאיר את "SSL שדה קובץ מפתח" ריק. האישור והמפתח עדיין חייבים להיות ב-PEM פוּרמָט. שילוב תעודה ומפתח קל:       cat client.crt client.key > client.pem   :::

en-us	#### Configuring certificate-based encryption for Zabbix agent  1\. Prepare files with top-level CA certificates, agent certificate (chain) and private key as described in [Configuring certificate on Zabbix server](/manual/encryption/using_certificates#configuring_certificate_on_zabbix_server). Edit parameters `TLSCAFile`, `TLSCertFile`, `TLSKeyFile` in agent configuration accordingly.  2\. For active checks edit `TLSConnect` parameter:      TLSConnect=cert  For passive checks edit `TLSAccept` parameter:      TLSAccept=cert  3\. Now you have a minimal certificate-based agent configuration. You may prefer to improve agent security by setting `TLSServerCertIssuer` and `TLSServerCertSubject` parameters. (see [Restricting allowed certificate Issuer and Subject](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject)).  4\. In final agent configuration file TLS parameters may look like:      TLSConnect=cert     TLSAccept=cert     TLSCAFile=/home/zabbix/zabbix_ca_file     TLSServerCertIssuer=CN=Signing CA,OU=Development group,O=Zabbix SIA,DC=zabbix,DC=com     TLSServerCertSubject=CN=Zabbix proxy,OU=Development group,O=Zabbix SIA,DC=zabbix,DC=com     TLSCertFile=/home/zabbix/zabbix_agentd.crt     TLSKeyFile=/home/zabbix/zabbix_agentd.key  (Example assumes that host is monitored via proxy, hence proxy certificate Subject.)  5\. Configure encryption for this agent in Zabbix frontend:  -   Go to: *Configuration → Hosts* -   Select host and click on **Encryption** tab  In example below Issuer and Subject fields are filled in - see [Restricting allowed certificate Issuer and Subject](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject) why and how to use these fields.  ![agent\_config.png](../../../assets/en/manual/encryption/agent_config.png)
he	#### הגדרת הצפנה מבוססת תעודות עבור סוכן Zabbix  1\. הכן קבצים עם תעודות CA ברמה העליונה, תעודת סוכן (שרשרת) ומפתח פרטי כמתואר ב-[הגדרת אישור מופעל זאביקס שרת](/manual/encryption/using_certificates#configuring_certificate_on_zabbix_server). ערוך פרמטרים `TLSCAFile`, `TLSCertFile`, `TLSKeyFile` בסוכן תצורה בהתאם.  2\. עבור בדיקות פעילות ערוך את הפרמטר 'TLSConnekt':       TLSConnect=cert  עבור בדיקות פסיביות ערוך פרמטר `TLSAccept`:       TLSAccept=cert  3\. כעת יש לך תצורת סוכן מינימלית מבוססת תעודות. אתה עשוי להעדיף לשפר את אבטחת הסוכן על ידי הגדרת 'TLSServerCertIssuer' ופרמטרים `TLSServerCertSubject`. (ראה [הגבלה מותרת מנפיק תעודה ו נושא](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject)).  4\. בקובץ התצורה הסופי של הסוכן הפרמטרים של TLS עשויים להיראות כך:       TLSConnect=cert      TLSAccept=cert      TLSCAFile=/home/zabbix/zabbix_ca_file      TLSServerCertIssuer=CN=חתימה CA,OU=קבוצת פיתוח,O=Zabbix SIA,DC=zabbix,DC=com      TLSServerCertSubject=CN=Proxy Zabbix,OU=קבוצת פיתוח,O=Zabbix SIA,DC=zabbix,DC=com      TLSCertFile=/home/zabbix/zabbix_agentd.crt      TLSKeyFile=/home/zabbix/zabbix_agentd.key  (הדוגמה מניחה שהמארח מנוטר באמצעות פרוקסי, ומכאן פרוקסי נושא התעודה.)  5\. הגדר הצפנה עבור סוכן זה בחזית Zabbix:  - עבור אל: *תצורה → מארחים* - בחר מארח ולחץ על הכרטיסייה **הצפנה**  בדוגמה למטה ממולאים שדות המנפיק והנושא - ראה [הגבלת אישור מותר מנפיק ו נושא](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject) מדוע וכיצד להשתמש בשדות אלו.  ![agent\_config.png](../../../assets/en/manual/encryption/agent_config.png)

en-us	#### Configuring certificate-based encryption for Zabbix proxy  1\. Prepare files with top-level CA certificates, proxy certificate (chain) and private key as described in [Configuring certificate on Zabbix server](/manual/encryption/using_certificates#configuring_certificate_on_zabbix_server). Edit parameters `TLSCAFile`, `TLSCertFile`, `TLSKeyFile` in proxy configuration accordingly.  2\. For active proxy edit `TLSConnect` parameter:      TLSConnect=cert  For passive proxy edit `TLSAccept` parameter:      TLSAccept=cert  3\. Now you have a minimal certificate-based proxy configuration. You may prefer to improve proxy security by setting `TLSServerCertIssuer` and `TLSServerCertSubject` parameters (see [Restricting allowed certificate Issuer and Subject](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject)).  4\. In final proxy configuration file TLS parameters may look like:      TLSConnect=cert     TLSAccept=cert     TLSCAFile=/home/zabbix/zabbix_ca_file     TLSServerCertIssuer=CN=Signing CA,OU=Development group,O=Zabbix SIA,DC=zabbix,DC=com     TLSServerCertSubject=CN=Zabbix server,OU=Development group,O=Zabbix SIA,DC=zabbix,DC=com     TLSCertFile=/home/zabbix/zabbix_proxy.crt     TLSKeyFile=/home/zabbix/zabbix_proxy.key  5\. Configure encryption for this proxy in Zabbix frontend:  -   Go to: *Administration → Proxies* -   Select proxy and click on **Encryption** tab  In examples below Issuer and Subject fields are filled in - see [Restricting allowed certificate Issuer and Subject](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject) why and how to use these fields.  For active proxy  ![proxy\_active\_cert.png](../../../assets/en/manual/encryption/proxy_active_cert.png)  For passive proxy  ![proxy\_passive\_cert.png](../../../assets/en/manual/encryption/proxy_passive_cert.png)
he	#### הגדרת הצפנה מבוססת תעודות עבור פרוקסי Zabbix  1\. הכן קבצים עם אישורי CA ברמה העליונה, אישור פרוקסי (שרשרת) ומפתח פרטי כמתואר ב-[הגדרת אישור מופעל זאביקס שרת](/manual/encryption/using_certificates#configuring_certificate_on_zabbix_server). ערוך פרמטרים `TLSCAFile`, `TLSCertFile`, `TLSKeyFile` ב-proxy תצורה בהתאם.  2\. עבור פרוקסי פעיל ערוך פרמטר 'TLSConnekt':       TLSConnect=cert  עבור פרוקסי פסיבי ערוך פרמטר 'TLSAccept':       TLSAccept=cert  3\. כעת יש לך תצורת proxy מינימלית מבוססת תעודות. אתה עשוי להעדיף לשפר את אבטחת ה-proxy על ידי הגדרת 'TLSServerCertIssuer' ופרמטרים `TLSServerCertSubject` (ראה [הגבלה מותרת מנפיק תעודה ו נושא](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject)).  4\. בקובץ תצורת ה-proxy הסופי פרמטרי TLS עשויים להיראות כך:       TLSConnect=cert      TLSAccept=cert      TLSCAFile=/home/zabbix/zabbix_ca_file      TLSServerCertIssuer=CN=חתימה CA,OU=קבוצת פיתוח,O=Zabbix SIA,DC=zabbix,DC=com      TLSServerCertSubject=CN=שרת Zabbix,OU=קבוצת פיתוח,O=Zabbix SIA,DC=zabbix,DC=com      TLSCertFile=/home/zabbix/zabbix_proxy.crt      TLSKeyFile=/home/zabbix/zabbix_proxy.key  5\. הגדר הצפנה עבור פרוקסי זה בחזית Zabbix:  - עבור אל: *ניהול ← פרוקסי* - בחר פרוקסי ולחץ על הכרטיסייה **הצפנה**  בדוגמאות להלן ממלאים שדות המנפיק והנושא - ראה [הגבלת אישור מותר מנפיק ו נושא](/manual/encryption/using_certificates#restricting_allowed_certificate_issuer_and_subject) מדוע וכיצד להשתמש בשדות אלו.  עבור פרוקסי פעיל  ![proxy\_active\_cert.png](../../../assets/en/manual/encryption/proxy_active_cert.png)  עבור פרוקסי פסיבי  ![proxy\_passive\_cert.png](../../../assets/en/manual/encryption/proxy_passive_cert.png)

en-us	#### Configuring JMX interfaces and items in Zabbix frontend  With Java gateway running, server knowing where to find it and a Java application started with support for remote JMX monitoring, it is time to configure the interfaces and items in Zabbix GUI.
he	#### קביעת תצורה של ממשקי JMX ופריטים בחזית Zabbix  כששער Java פועל, השרת יודע היכן למצוא אותו ו-Java יישום שהתחיל עם תמיכה בניטור JMX מרחוק, הגיע הזמן כדי להגדיר את הממשקים והפריטים ב- Zabbix GUI.

en-us	##### Configuring JMX interface  You begin by creating a JMX-type interface on the host of interest.\ ![](../../../../../assets/en/manual/config/items/itemtypes/jmx_interface.png){width="600"}  All mandatory input fields are marked with a red asterisk.
he	##### הגדרת ממשק JMX  אתה מתחיל ביצירת ממשק מסוג JMX במארח העניין.\ ![](../../../../../assets/en/manual/config/items/itemtypes/jmx_interface.png){width="600"}  כל שדות הקלט החובה מסומנים בכוכבית אדומה.

en-us	#### Configuring low-level discovery rules  See the [low-level discovery](/manual/discovery/low_level_discovery) section of the manual.
he	#### הגדרת כללי גילוי ברמה נמוכה  ראה את [גילוי ברמה נמוכה](/manual/discovery/low_level_discovery) סעיף של המדריך.

en-us	### Configuring low-level discovery  We will illustrate low-level discovery based on an example of file system discovery.  To configure the discovery, do the following:  -   Go to: *Configuration* → *Templates* or *Hosts* -   Click on *Discovery* in the row of an appropriate template/host  ![](../../../assets/en/manual/discovery/low_level_discovery/fs_templates.png)  -   Click on *Create discovery rule* in the upper right corner of the     screen -   Fill in the discovery rule form with the required details
he	### הגדרת גילוי ברמה נמוכה  נמחיש גילוי ברמה נמוכה על סמך דוגמה של קובץ גילוי מערכת.  כדי להגדיר את הגילוי, בצע את הפעולות הבאות:  - עבור אל: *תצורה* ← *תבניות* או *מארחים* - לחץ על *גילוי* בשורה של תבנית/מארח מתאים  ![](../../../assets/en/manual/discovery/low_level_discovery/fs_templates.png)  - לחץ על *צור כלל גילוי* בפינה הימנית העליונה של      מָסָך - מלא את טופס כלל הגילוי עם הפרטים הנדרשים

en-us	#### Configuring nested templates  To link templates, you need to take an existing template or a new one, and then:  -   Open the [template configuration form](/manual/config/templates/template#creating-a-template) -   Find the *Templates* field -   Click *Select* to open the *Templates* popup window -   In the popup window, choose required templates, then click *Select* to add the templates to the list -   Click *Add* or *Update* in the template configuration form  Thus, all entities of the parent template, as well as all entities of linked templates (such as items, triggers, graphs, etc.) will now appear in the template configuration, except for linked template dashboards, which will, nevertheless, be inherited by hosts.  To unlink any of the linked templates, in the same form use the *Unlink* or *Unlink and clear* buttons and click *Update*.  Choosing the *Unlink* option will simply remove the association with the linked template, while not removing all its entities (items, triggers, graphs, etc.).  Choosing the *Unlink and clear* option will remove both the association with the linked template and all its entities (items, triggers, graphs, etc.).
he	#### הגדרת תבניות מקוננות  כדי לקשר תבניות, עליך לקחת תבנית קיימת או חדשה, ולאחר מכן:  - פתח את [טופס תצורת התבנית](/manual/config/templates/template#creating-a-template) - מצא את השדה *תבניות* - לחץ על *בחר* כדי לפתוח את החלון הקופץ *תבניות* - בחלון הקופץ, בחר את התבניות הנדרשות ולאחר מכן לחץ על *בחר* כדי להוסיף את התבניות לרשימה - לחץ על *הוסף* או *עדכן* בטופס תצורת התבנית  לפיכך, כל הישויות של תבנית האב, כמו גם כל הישויות של תבניות מקושרות (כגון פריטים, טריגרים, גרפים וכו') יופיעו כעת בתצורת התבנית, למעט תבנית מקושרת לוחות מחוונים, אשר בכל זאת עברו בירושה למארחים.  כדי לבטל קישור של כל אחת מהתבניות המקושרות, באותו טופס השתמש ב-*בטל קישור* או כפתורי *בטל קישור ומנקה* ולחץ על *עדכן*.  בחירה באפשרות *בטל קישור* פשוט תסיר את השיוך עם תבנית מקושרת, תוך אי הסרת כל הישויות שלה (פריטים, טריגרים, גרפים וכו').  בחירה באפשרות *בטל קישור ונקה* תסיר את שתי השיוך עם התבנית המקושרת וכל הישויות שלה (פריטים, טריגרים, גרפים וכו').

en-us	##### Configuring Perl trap receiver  Requirements: Perl, Net-SNMP compiled with --enable-embedded-perl (done by default since Net-SNMP 5.4)  A Perl trap receiver (look for misc/snmptrap/zabbix\_trap\_receiver.pl) can be used to pass traps to Zabbix server directly from snmptrapd. To configure it:  -   add the Perl script to the snmptrapd configuration file     (snmptrapd.conf), e.g.:  ```perl perl do "[FULL PATH TO PERL RECEIVER SCRIPT]"; ```  -   configure the receiver, e.g:  ```ini $SNMPTrapperFile = '[TRAP FILE]'; $DateTimeFormat = '[DATE TIME FORMAT]'; ```  ::: notetip If the script name is not quoted, snmptrapd will refuse to start up with messages, similar to these:<br><br>  ```yaml Regexp modifiers "/l" and "/a" are mutually exclusive at (eval 2) line 1, at end of line Regexp modifier "/l" may not appear twice at (eval 2) line 1, at end of line ```  :::
he	##### הגדרת מקלט מלכודת Perl  דרישות: Perl, Net-SNMP הידור עם --enable-embedded-perl (בוצע כברירת מחדל מאז Net-SNMP 5.4)  מקלט מלכודת Perl (חפש את misc/snmptrap/zabbix\_trap\_receiver.pl) ניתן להשתמש כדי להעביר מלכודות לשרת Zabbix ישירות מ-snmptrapd. ל להגדיר את זה:  - הוסף את סקריפט Perl לקובץ התצורה snmptrapd      (snmptrapd.conf), למשל:  ```פרל perl לעשות "[מסלול מלא ל-PERL RECEIVER SCRIPT]"; ```  - הגדר את המקלט, למשל:  ``` איני $SNMPTrapperFile = '[קובץ מלכודת]'; $DateTimeFormat = '[פורמט תאריך שעה]'; ```  ::: הערה אם שם הסקריפט לא מצוטט, snmptrapd יסרב לעשות זאת התחל עם הודעות, דומות לאלה:<br><br>  ``` יאמל השינויים ב-Regexp "/l" ו-"/a" סותרים זה את זה בשורה 1 (eval 2), בסוף השורה יתכן שהשינוי הרגולרי "/l" לא יופיע פעמיים בשורה 1 (בערך 2), בסוף השורה ```  :::

en-us	#### Configuring PSK for server - active proxy communication (example)  On the proxy, write the PSK value into a file, for example, `/home/zabbix/zabbix_proxy.psk`. The file must contain PSK in the first text string, for example:      e560cb0d918d26d31b4f642181f5f570ad89a390931102e5391d08327ba434e9  Set access rights to PSK file - it must be readable only by Zabbix user.  Edit TLS parameters in proxy configuration file `zabbix_proxy.conf`, for example, set:      TLSConnect=psk     TLSPSKFile=/home/zabbix/zabbix_proxy.psk     TLSPSKIdentity=PSK 002  The proxy will connect to server using PSK. PSK identity will be "PSK 002".  (To minimize downtime see how to change connection type in [Connection encryption management](/manual/encryption#connection_encryption_management)).  Configure PSK for this proxy in Zabbix frontend. Go to *Administration→Proxies*, select the proxy, go to "Encryption" tab. In "Connections from proxy" mark `PSK`. Paste into "PSK identity" field "PSK 002" and "e560cb0d918d26d31b4f642181f5f570ad89a390931102e5391d08327ba434e9" into "PSK" field. Click "Update".  Restart proxy. It will start using PSK-based encrypted connections to server. Check server and proxy logfiles for error messages.  For a passive proxy the procedure is very similar. The only difference - set `TLSAccept=psk` in proxy configuration file and set "Connections to proxy" in Zabbix frontend to `PSK`.
he	#### הגדרת PSK עבור שרת - תקשורת פרוקסי פעילה (דוגמה)  בפרוקסי, כתוב את ערך ה-PSK לקובץ, למשל, `/home/zabbix/zabbix_proxy.psk`. הקובץ חייב להכיל PSK בראשון מחרוזת טקסט, למשל:       e560cb0d918d26d31b4f642181f5f570ad89a390931102e5391d08327ba434e9  הגדר זכויות גישה לקובץ PSK - עליו להיות קריא רק למשתמש Zabbix.  ערוך פרמטרים של TLS בקובץ תצורת ה-proxy `zabbix_proxy.conf`, עבור דוגמה, הגדר:       TLSConnect=psk      TLSPSKFile=/home/zabbix/zabbix_proxy.psk      TLSPSKIdentity=PSK 002  ה-proxy יתחבר לשרת באמצעות PSK. זהות PSK תהיה "PSK 002".  (כדי למזער את זמן ההשבתה, ראה כיצד לשנות את סוג החיבור ב-[חיבור הצפנה management](/manual/encryption#connection_encryption_management)).  הגדר את PSK עבור פרוקסי זה בחזית Zabbix. לך ל *ניהול → פרוקסי*, בחר את ה-proxy, עבור ללשונית "הצפנה". ב "חיבורים מ-proxy" סמן 'PSK'. הדבק בשדה "זהות PSK". "PSK 002" ו "e560cb0d918d26d31b4f642181f5f570ad89a390931102e5391d08327ba434e9" לתוך שדה "PSK". לחץ על "עדכן".  הפעל מחדש את ה-proxy. זה יתחיל להשתמש בחיבורים מוצפנים מבוססי PSK ל שרת. בדוק אם יש הודעות שגיאה בקובצי היומן של השרת וה-proxy.  עבור פרוקסי פסיבי ההליך דומה מאוד. ההבדל היחיד - הגדר 'TLSAccept=psk' בקובץ תצורת ה-proxy והגדר "חיבורים ל proxy" בחזית Zabbix ל-PSK.

en-us	#### Configuring server for use with Java gateway  With Java gateway up and running, you have to tell Zabbix server where to find Zabbix Java gateway. This is done by specifying JavaGateway and JavaGatewayPort parameters in the [server configuration file](/manual/appendix/config/zabbix_server). If the host on which JMX application is running is monitored by Zabbix proxy, then you specify the connection parameters in the [proxy configuration file](/manual/appendix/config/zabbix_proxy) instead.      JavaGateway=192.168.3.14     JavaGatewayPort=10052  By default, server does not start any processes related to JMX monitoring. If you wish to use it, however, you have to specify the number of pre-forked instances of Java pollers. You do this in the same way you specify regular pollers and trappers.      StartJavaPollers=5  Do not forget to restart server or proxy, once you are done with configuring them.
he	#### הגדרת שרת לשימוש עם שער Java  כששער Java פועל, עליך לומר לשרת Zabbix היכן כדי למצוא את Zabbix Java gateway. זה נעשה על ידי ציון JavaGateway ו פרמטרים של JavaGatewayPort ב-[תצורת השרת file](/manual/appendix/config/zabbix_server). אם המארח שבו JMX האפליקציה פועלת מנוטרת על ידי פרוקסי Zabbix, ולאחר מכן תציין פרמטרי החיבור ב-[תצורת proxy file](/manual/appendix/config/zabbix_proxy) במקום זאת.       JavaGateway=192.168.3.14      JavaGatewayPort=10052  כברירת מחדל, השרת אינו מתחיל תהליכים הקשורים ל-JMX ניטור. אם אתה רוצה להשתמש בו, עם זאת, עליך לציין את מספר מופעים מפורקים מראש של משאלי Java. אתה עושה את זה באותו אופן הדרך שבה אתה מציין סקרים ולוכדים רגילים.       StartJavaPollers=5  אל תשכח להפעיל מחדש את השרת או ה-proxy, לאחר שתסיים עם להגדיר אותם.

en-us	#### Configuring server for use with Java gateway  With Java gateway up and running, you have to tell Zabbix server where to find Zabbix Java gateway. This is done by specifying JavaGateway and JavaGatewayPort parameters in the [server configuration file](/manual/appendix/config/zabbix_server). If the host on which JMX application is running is monitored by Zabbix proxy, then you specify the connection parameters in the [proxy configuration file](/manual/appendix/config/zabbix_proxy) instead.      JavaGateway=192.168.3.14     JavaGatewayPort=10052  By default, server does not start any processes related to JMX monitoring. If you wish to use it, however, you have to specify the number of pre-forked instances of Java pollers. You do this in the same way you specify regular pollers and trappers.      StartJavaPollers=5  Do not forget to restart server or proxy, once you are done with configuring them.
he	#### הגדרת שרת לשימוש עם שער Java  כששער Java פועל, עליך לומר לשרת Zabbix היכן כדי למצוא את Zabbix Java gateway. זה נעשה על ידי ציון JavaGateway ו פרמטרים של JavaGatewayPort ב-[תצורת השרת file](/manual/appendix/config/zabbix_server). אם המארח שבו JMX האפליקציה פועלת מנוטרת על ידי פרוקסי Zabbix, ולאחר מכן תציין פרמטרי החיבור ב-[תצורת proxy file](/manual/appendix/config/zabbix_proxy) במקום זאת.       JavaGateway=192.168.3.14      JavaGatewayPort=10052  כברירת מחדל, השרת אינו מתחיל תהליכים הקשורים ל-JMX ניטור. אם אתה רוצה להשתמש בו, עם זאת, עליך לציין את מספר מופעים מפורקים מראש של משאלי Java. אתה עושה את זה באותו אופן הדרך שבה אתה מציין סקרים ולוכדים רגילים.       StartJavaPollers=5  אל תשכח להפעיל מחדש את השרת או ה-proxy, לאחר שתסיים עם להגדיר אותם.

en-us	#### Configuring server for use with Java gateway  With Java gateway up and running, you have to tell Zabbix server where to find Zabbix Java gateway. This is done by specifying JavaGateway and JavaGatewayPort parameters in the [server configuration file](/manual/appendix/config/zabbix_server). If the host on which JMX application is running is monitored by Zabbix proxy, then you specify the connection parameters in the [proxy configuration file](/manual/appendix/config/zabbix_proxy) instead.      JavaGateway=192.168.3.14     JavaGatewayPort=10052  By default, server does not start any processes related to JMX monitoring. If you wish to use it, however, you have to specify the number of pre-forked instances of Java pollers. You do this in the same way you specify regular pollers and trappers.      StartJavaPollers=5  Do not forget to restart server or proxy, once you are done with configuring them.
he	#### הגדרת שרת לשימוש עם שער Java  כששער Java פועל, עליך לומר לשרת Zabbix היכן כדי למצוא את Zabbix Java gateway. זה נעשה על ידי ציון JavaGateway ו פרמטרים של JavaGatewayPort ב-[תצורת השרת file](/manual/appendix/config/zabbix_server). אם המארח שבו JMX האפליקציה פועלת מנוטרת על ידי פרוקסי Zabbix, ולאחר מכן תציין פרמטרי החיבור ב-[תצורת proxy file](/manual/appendix/config/zabbix_proxy) במקום זאת.       JavaGateway=192.168.3.14      JavaGatewayPort=10052  כברירת מחדל, השרת אינו מתחיל תהליכים הקשורים ל-JMX ניטור. אם אתה רוצה להשתמש בו, עם זאת, עליך לציין את מספר מופעים מפורקים מראש של משאלי Java. אתה עושה את זה באותו אופן הדרך שבה אתה מציין סקרים ולוכדים רגילים.       StartJavaPollers=5  אל תשכח להפעיל מחדש את השרת או ה-proxy, לאחר שתסיים עם להגדיר אותם.

en-us	#### Configuring server for use with Java gateway  With Java gateway up and running, you have to tell Zabbix server where to find Zabbix Java gateway. This is done by specifying JavaGateway and JavaGatewayPort parameters in the [server configuration file](/manual/appendix/config/zabbix_server). If the host on which JMX application is running is monitored by Zabbix proxy, then you specify the connection parameters in the [proxy configuration file](/manual/appendix/config/zabbix_proxy) instead.      JavaGateway=192.168.3.14     JavaGatewayPort=10052  By default, server does not start any processes related to JMX monitoring. If you wish to use it, however, you have to specify the number of pre-forked instances of Java pollers. You do this in the same way you specify regular pollers and trappers.      StartJavaPollers=5  Do not forget to restart server or proxy, once you are done with configuring them.
he	#### הגדרת שרת לשימוש עם שער Java  כששער Java פועל, עליך לומר לשרת Zabbix היכן כדי למצוא את Zabbix Java gateway. זה נעשה על ידי ציון JavaGateway ו פרמטרים של JavaGatewayPort ב-[תצורת השרת file](/manual/appendix/config/zabbix_server). אם המארח שבו JMX האפליקציה פועלת מנוטרת על ידי פרוקסי Zabbix, ולאחר מכן תציין פרמטרי החיבור ב-[תצורת proxy file](/manual/appendix/config/zabbix_proxy) במקום זאת.       JavaGateway=192.168.3.14      JavaGatewayPort=10052  כברירת מחדל, השרת אינו מתחיל תהליכים הקשורים ל-JMX ניטור. אם אתה רוצה להשתמש בו, עם זאת, עליך לציין את מספר מופעים מפורקים מראש של משאלי Java. אתה עושה את זה באותו אופן הדרך שבה אתה מציין סקרים ולוכדים רגילים.       StartJavaPollers=5  אל תשכח להפעיל מחדש את השרת או ה-proxy, לאחר שתסיים עם להגדיר אותם.

en-us	#### Configuring SNMP monitoring  To start monitoring a device through SNMP, the following steps have to be performed:
he	#### הגדרת ניטור SNMP  כדי להתחיל לנטר מכשיר דרך SNMP, יש לבצע את השלבים הבאים לְהֵעָשׂוֹת:

en-us	#### Configuring SNMP traps  Configuring the following fields in the frontend is specific for this item type:  -   Your host must have an SNMP interface  In *Configuration → Hosts*, in the **Host interface** field set an SNMP interface with the correct IP or DNS address. The address from each received trap is compared to the IP and DNS addresses of all SNMP interfaces to find the corresponding hosts.  -   Configure the item  In the **Key** field use one of the SNMP trap keys:  |Key|<|<| |--|--|------| |Description|Return value|Comments| |**snmptrap**\[regexp\]|<|<| |Catches all SNMP traps that match the [regular expression](/manual/regular_expressions) specified in **regexp**. If regexp is unspecified, catches any trap.|SNMP trap|This item can be set only for SNMP interfaces.<br>User macros and global regular expressions are supported in the parameter of this item key.| |**snmptrap.fallback**|<|<| |Catches all SNMP traps that were not caught by any of the snmptrap\[\] items for that interface.|SNMP trap|This item can be set only for SNMP interfaces.|  ::: noteclassic Multiline regular expression matching is not supported at this time. :::  Set the **Type of information** to 'Log' for the timestamps to be parsed. Note that other formats such as 'Numeric' are also acceptable but might require a custom trap handler.  ::: notetip For SNMP trap monitoring to work, it must first be set up  correctly (see below). :::
he	#### הגדרת מלכודות SNMP  הגדרת השדות הבאים ב-frontend היא ספציפית לכך סוג פריט:  - המארח שלך חייב להיות בעל ממשק SNMP  ב-*תצורה → מארחים*, בשדה **ממשק מארח** הגדר SNMP ממשק עם כתובת ה-IP או ה-DNS הנכונה. הכתובת מכל אחד מלכודת שקיבל מושווה לכתובות ה-IP וה-DNS של כל ה-SNMP ממשקים כדי למצוא את המארחים המתאימים.  - הגדר את הפריט  בשדה **מפתח** השתמש באחד ממפתחות המלכודת של SNMP:  |מפתח|<|<| |--|--|------| |תיאור|ערך החזרה|הערות| |**snmptrap**\[regexp\]|<|<| |תופס את כל מלכודות ה-SNMP שתואמות ל[ביטוי הרגולרי](/manual/regular_expressions) שצוין ב-**regexp**. אם הביטוי הרגולרי אינו צוין, תופס כל trap.|SNMP trap|ניתן להגדיר פריט זה רק עבור ממשקי SNMP.<br>פקודות מאקרו של משתמש וביטויים רגולריים גלובליים נתמכים בפרמטר של מפתח פריט זה.| |**snmptrap.fallback**|<|<| |תופס את כל מלכודות ה-SNMP שלא נתפסו על ידי אף אחד מהפריטים snmptrap\[\] עבור ממשק זה.|SNMP trap|ניתן להגדיר פריט זה רק עבור ממשקי SNMP.|  ::: noteclassic התאמת ביטוי רגולרי מרובה שורות אינה נתמכת בשלב זה זְמַן. :::  הגדר את **סוג המידע** ל'יומן' עבור חותמות הזמן מנותח. שים לב שגם פורמטים אחרים כגון 'נומרי' קבילים אך עשוי לדרוש מטפל מלכודות מותאם אישית.  ::: הערה כדי שניטור מלכודות SNMP יפעל, תחילה יש להגדיר אותו בצורה נכונה (ראה להלן). :::

en-us	#### Configuring steps  ![](../../assets/en/manual/config/scenario_step.png){width="600"}  Step parameters:  |Parameter|Description| |--|--------| |*Name*|Unique step name.<br>[User macros](/manual/config/macros/user_macros) are supported. *Note* that if user macros are used, these macros will be left unresolved in [web monitoring item](/manual/web_monitoring/items) names.| |*URL*|URL to connect to and retrieve data. For example:<br>https://www.example.com<br>http://www.example.com/download<br>Domain names can be specified in Unicode characters. They are automatically punycode-converted to ASCII when executing the web scenario step.<br>The *Parse* button can be used to separate optional query fields (like ?name=Admin&password=mypassword) from the URL, moving the attributes and values into *Query fields* for automatic URL-encoding.<br>Variables can be used in the URL, using the {macro} syntax. Variables can be URL-encoded manually using a {{macro}.urlencode()} syntax.<br>User macros and {HOST.\*} [macros](/manual/appendix/macros/supported_by_location) are supported.<br>Limited to 2048 characters.| |*Query fields*|HTTP GET variables for the URL.<br>Specified as attribute and value pairs.<br>Values are URL-encoded automatically. Values from scenario variables, user macros or {HOST.\*} macros are resolved and then URL-encoded automatically. Using a {{macro}.urlencode()} syntax will double URL-encode them.<br>User macros and {HOST.\*} [macros](/manual/appendix/macros/supported_by_location) are supported.| |*Post*|HTTP POST variables.<br>In **Form data** mode, specified as attribute and value pairs.<br>Values are URL-encoded automatically. Values from scenario variables, user macros or {HOST.\*} macros are resolved and then URL-encoded automatically.<br>In **Raw data** mode, attributes/values are displayed on a single line and concatenated with a **&** symbol.<br>Raw values can be URL-encoded/decoded manually using a {{macro}.urlencode()} or {{macro}.urldecode()} syntax.<br>For example: id=2345&userid={user}<br>If {user} is defined as a variable of the web scenario, it will be replaced by its value when the step is executed. If you wish to URL-encode the variable, substitute {user} with {{user}.urlencode()}.<br>User macros and {HOST.\*} [macros](/manual/appendix/macros/supported_by_location) are supported.| |*Variables*|Step-level variables that may be used for GET and POST functions.<br>Specified as attribute and value pairs.<br>Step-level variables override scenario-level variables or variables from the previous step. However, the value of a step-level variable only affects the step after (and not the current step).<br>They have the following format:<br>**{macro}**=value<br>**{macro}**=regex:<regular expression><br>For more information see variable description on the [scenario](web_monitoring#configuring_a_web_scenario) level.<br>Variables are automatically URL-encoded when used in query fields or form data for post variables, but must be URL-encoded manually when used in raw post or directly in URL.| |*Headers*|Custom HTTP headers that will be sent when performing a request.<br>Specified as attribute and value pairs.<br>A header defined on a step level will be used for that particular step.<br>**It should be noted that defining the header on a step level automatically discards all the previously defined headers, except for a default header that is assigned by selecting the 'User-Agent' from a drop-down list on a scenario level.**<br>However, even the 'User-Agent' default header can be overridden by specifying it on a step level.<br>For example, assigning the name to a header, but setting no value will unset the default header on a scenario level.<br>User macros and {HOST.\*} macros are supported.<br>This sets the [CURLOPT\_HTTPHEADER](http://curl.haxx.se/libcurl/c/CURLOPT_HTTPHEADER.html) cURL option.<br>Specifying custom headers is supported *starting with Zabbix 2.4*.| |*Follow redirects*|Mark the checkbox to follow HTTP redirects.<br>This sets the [CURLOPT\_FOLLOWLOCATION](http://curl.haxx.se/libcurl/c/CURLOPT_FOLLOWLOCATION.html) cURL option.| |*Retrieve mode*|Select the retrieve mode:<br>**Body** - retrieve only body from the HTTP response<br>**Headers** - retrieve only headers from the HTTP response<br>**Body and headers** - retrieve body and headers from the HTTP response| |*Timeout*|Zabbix will not spend more than the set amount of time on processing the URL (from one second to maximum of 1 hour). Actually this parameter defines the maximum time for making connection to the URL and maximum time for performing an HTTP request. Therefore, Zabbix will not spend more than **2 x Timeout** seconds on the step.<br>[Time suffixes](/manual/appendix/suffixes) are supported, e.g. 30s, 1m, 1h. [User macros](/manual/config/macros/user_macros) are supported.| |*Required string*|Required regular expression pattern.<br>Unless retrieved content (HTML) matches the required pattern the step will fail. If empty, no check on required string is performed.<br>For example:<br>Homepage of Zabbix<br>Welcome.\*admin<br>*Note*: Referencing [regular expressions](regular_expressions) created in the Zabbix frontend is not supported in this field.<br>User macros and {HOST.\*} [macros](/manual/appendix/macros/supported_by_location) are supported.| |*Required status codes*|List of expected HTTP status codes. If Zabbix gets a code which is not in the list, the step will fail.<br>If empty, no check on status codes is performed.<br>For example: 200,201,210-299<br>User macros are supported.|  ::: noteclassic Any changes in web scenario steps will only be saved when the whole scenario is saved. :::  See also a [real-life example](/manual/web_monitoring/example) of how web monitoring steps can be configured.
he	#### הגדרת תרחיש אינטרנט  כדי להגדיר תרחיש אינטרנט:  - עבור אל: *תצורה ← מארחים* (או *תבניות*) - לחץ על *אינטרנט* בשורה של המארח/תבנית - לחץ על *צור תרחיש* מימין (או על שם התרחיש אל      ערוך תרחיש קיים) - הזן פרמטרים של התרחיש בטופס  הכרטיסייה **תרחיש** מאפשרת לך להגדיר את הפרמטרים הכלליים של א תרחיש אינטרנט.  ![](../../assets/en/manual/config/scenario.png)  כל שדות הקלט החובה מסומנים בכוכבית אדומה.  פרמטרים של תרחיש:  |פרמטר|תיאור| |--|--------| |*שם*|שם תרחיש ייחודי.<br>[פקודות מאקרו משתמש](/manual/config/macros/user_macros) נתמכות. *שים לב* שאם נעשה שימוש בפקודות מאקרו של משתמש, פקודות מאקרו אלו יישארו ללא פתרון בשמות [פריט ניטור אינטרנט](/manual/web_monitoring/items).| |*מרווח עדכון*|באיזו תדירות יתבצע התרחיש.<br>[סיומות זמן](/manual/appendix/suffixes) נתמכות, למשל. 30s, 1m, 2h, 1d.<br>[פקודות מאקרו משתמש](/manual/config/macros/user_macros) נתמכות. *שים לב* שאם נעשה שימוש במאקרו משתמש והערך שלו משתנה (למשל 5m → 30s), הבדיקה הבאה תתבצע לפי הערך הקודם (רחוק יותר בעתיד עם הערכים לדוגמה).| |*ניסיונות*|מספר הניסיונות לביצוע שלבי תרחיש אינטרנט. במקרה של בעיות רשת (פסק זמן, אין קישוריות וכו') Zabbix יכולה לחזור על ביצוע שלב מספר פעמים. ערכת הדמויות תשפיע באותה מידה על כל שלב בתרחיש. ניתן לציין עד 10 ניסיונות, ערך ברירת המחדל הוא 1.<br>*הערה*: Zabbix לא יחזור על שלב בגלל קוד תגובה שגוי או אי התאמה של מחרוזת נדרשת.| |*סוכן*|בחר סוכן לקוח.<br>Zabbix יעמיד פנים שהוא הדפדפן שנבחר. זה שימושי כאשר אתר מחזיר תוכן שונה עבור דפדפנים שונים.<br>ניתן להשתמש בפקודות מאקרו של משתמשים בשדה זה.| |*HTTP proxy*|אתה יכול לציין פרוקסי HTTP לשימוש, באמצעות הפורמט `[protocol://][username[:password]@]proxy.example.com[:port]`.<br>זה מגדיר את [CURLOPT\_PROXY](https://curl.haxx.se/libcurl/c/CURLOPT_PROXY.html) אפשרות cURL.<br>ניתן להשתמש בקידומת `protocol://` האופציונלית כדי לציין פרוטוקולי proxy חלופיים (הפרוטוקול נוספה תמיכת קידומת ב-cURL 7.21.7). ללא פרוטוקול, ה-proxy יטופל כאל פרוקסי HTTP.<br>כברירת מחדל, ייעשה שימוש ביציאת 1080.<br>אם צוין, ה-proxy ידרוס משתני סביבה הקשורים ל-proxy כמו http\_proxy, HTTPS\_PROXY. אם לא צוין, ה-proxy לא יחליף משתני סביבה הקשורים ל-proxy. הערך שהוזן מועבר "כפי שהוא", לא מתבצעת בדיקת שפיות.<br>תוכל גם להזין כתובת פרוקסי של SOCKS. אם תציין את הפרוטוקול השגוי, החיבור ייכשל והפריט לא יהיה נתמך.<br>*שים לב* שרק אימות פשוט נתמך עם פרוקסי HTTP.<br>ניתן להשתמש בפקודות מאקרו של משתמשים בשדה זה.| |*משתנים*|משתנים שניתן להשתמש בהם בשלבי תרחיש (כתובת אתר, משתני פרסום).<br>יש להם את הפורמט הבא:<br>**{macro1}**=value1<br>**{macro2}* *=value2<br>**{macro3}**=regex:<regular expression><br>לדוגמה:<br>{username}=Alexei<br>{password}=kj3h5kJ34bd<br>{hostid}=regex :hostid הוא (\[0-9\]+)<br>לאחר מכן ניתן להתייחס לפקודות המאקרו בשלבים כמו {username}, {password} ו-{hostid}. Zabbix יחליף אותם אוטומטית בערכים בפועל. שים לב שמשתנים עם `regex:` צריכים שלב אחד כדי לקבל את הערך של הביטוי הרגולרי כך שניתן להחיל את הערך שחולץ רק על השלב שאחרי.<br>אם חלק הערך מתחיל ב-`regex:` אז החלק שאחריו מתייחסים אליו כאל ביטוי רגולרי שמחפש בדף האינטרנט, ואם הוא נמצא, מאחסן את ההתאמה במשתנה. לפחות תת-קבוצה אחת חייבת להיות נוכחת כדי שניתן יהיה לחלץ את הערך המותאם.<br>פקודות מאקרו משתמש ו-{HOST.\*} [macros](/manual/appendix/macros/supported_by_location) נתמכות.<br>משתנים נתמכים באופן אוטומטי מקודדת כתובת URL בשימוש בשדות שאילתה או בנתוני טופס עבור משתני פוסט, אך חייבת להיות מקודדת ידנית ב-URL בשימוש בפוסט גולמי או ישירות ב-URL.| |*כותרות*|כותרות HTTP משמשות בעת ביצוע בקשה. ניתן להשתמש בכותרות ברירת מחדל ובכותרות מותאמות אישית.<br>כותרות יוקצו באמצעות הגדרות ברירת המחדל בהתאם לסוג הסוכן שנבחר מרשימה נפתחת ברמת התרחיש, ויחולו על כל השלבים, אלא אם כן הם מוגדרים בהתאמה אישית ב רמת שלב.<br>**יש לשים לב שהגדרת הכותרת ברמת השלב מבטלת אוטומטית את כל הכותרות שהוגדרו קודם לכן, למעט כותרת ברירת מחדל המוקצית על ידי בחירת 'User-Agent' מתוך תפריט נפתח רשימה ברמת תרחיש.**<br>עם זאת, ניתן לעקוף אפילו את כותרת ברירת המחדל 'User-Agent' על ידי ציון שלה ברמת שלב.<br>כדי לבטל את הגדרת הכותרת ברמת תרחיש, יש לתת לכותרת את השם ומיוחס ללא ערך ברמת השלבים.<br>יש לרשום כותרות באמצעות אותו תחביר כפי שהן יופיעו בפרוטוקול HTTP, אופציונלי באמצעות כמה תכונות נוספות הנתמכות על ידי [CURLOPT\_HTTPHEADER](http://curl. haxx.se/libcurl/c/CURLOPT_HTTPHEADER.html) אפשרות cURL

en-us	#### Configuring tags  The **Tags** tab allows to define scenario-level [tags](/manual/config/tagging).  ![](../../assets/en/manual/config/scenario_c.png)  Tagging allows to filter web scenarios and web monitoring [items](/manual/web_monitoring/items).
he	#### הגדרת תגים  הכרטיסייה **תגים** מאפשרת להגדיר ברמת התרחיש [תגים](/manual/config/tagging).  ![](../../assets/en/manual/config/scenario_c.png)  תיוג מאפשר לסנן תרחישי אינטרנט וניטור אינטרנט [items](/manual/web_monitoring/items).

en-us	#### Connection encryption management  Connections in Zabbix can use:  -   no encryption (default) -   [RSA certificate-based     encryption](/manual/encryption/using_certificates) -   [PSK-based encryption](/manual/encryption/using_pre_shared_keys)  There are two important parameters used to specify encryption between Zabbix components:  -   TLSConnect - specifies what encryption to use for outgoing     connections (unencrypted, PSK or certificate) -   TLSAccept - specifies what types of connections are allowed for     incoming connections (unencrypted, PSK or certificate). One or more     values can be specified.  `TLSConnect` is used in the configuration files for Zabbix proxy (in active mode, specifies only connections to server) and Zabbix agent (for active checks). In Zabbix frontend the TLSConnect equivalent is the *Connections to host* field in *Configuration → Hosts → <some host> → Encryption* tab and the *Connections to proxy* field in *Administration → Proxies → <some proxy> → Encryption* tab. If the configured encryption type for connection fails, no other encryption types will be tried.  `TLSAccept` is used in the configuration files for Zabbix proxy (in passive mode, specifies only connections from server) and Zabbix agent (for passive checks). In Zabbix frontend the TLSAccept equivalent is the *Connections from host* field in *Configuration → Hosts → <some host> → Encryption* tab and the *Connections from proxy* field in *Administration → Proxies → <some proxy> → Encryption* tab.  Normally you configure only one type of encryption for incoming encryptions. But you may want to switch the encryption type, e.g. from unencrypted to certificate-based with minimum downtime and rollback possibility. To achieve this:  -   Set `TLSAccept=unencrypted,cert` in the agent configuration file and     restart Zabbix agent -   Test connection with zabbix\_get to the agent using certificate. If     it works, you can reconfigure encryption for that agent in Zabbix     frontend in the *Configuration → Hosts → <some host> →     Encryption* tab by setting *Connections to host* to "Certificate". -   When server configuration cache gets updated (and proxy     configuration is updated if the host is monitored by proxy) then     connections to that agent will be encrypted -   If everything works as expected you can set `TLSAccept=cert` in the     agent configuration file and restart Zabbix agent. Now the agent     will be accepting only encrypted certificate-based connections.     Unencrypted and PSK-based connections will be rejected.  In a similar way it works on server and proxy. If in Zabbix frontend in host configuration *Connections from host* is set to "Certificate" then only certificate-based encrypted connections will be accepted from the agent (active checks) and zabbix\_sender (trapper items).  Most likely you will configure incoming and outgoing connections to use the same encryption type or no encryption at all. But technically it is possible to configure it asymmetrically, e.g. certificate-based encryption for incoming and PSK-based for outgoing connections.  Encryption configuration for each host is displayed in the Zabbix frontend, in *Configuration → Hosts* in the *Agent encryption* column. For example:  |Example|Connections to host|Allowed connections from host|Rejected connections from host| |-------|-------------------|-------------------|-------------------| |![none\_none.png](../../assets/en/manual/encryption/none_none.png)|Unencrypted|Unencrypted|Encrypted, certificate and PSK-based encrypted| |![cert\_cert.png](../../assets/en/manual/encryption/cert_cert.png)|Encrypted, certificate-based|Encrypted, certificate-based|Unencrypted and PSK-based encrypted| |![psk\_psk.png](../../assets/en/manual/encryption/psk_psk.png)|Encrypted, PSK-based|Encrypted, PSK-based|Unencrypted and certificate-based encrypted| |![psk\_none\_psk.png](../../assets/en/manual/encryption/psk_none_psk.png)|Encrypted, PSK-based|Unencrypted and PSK-based encrypted|Certificate-based encrypted| |![cert\_all.png](../../assets/en/manual/encryption/cert_all.png)|Encrypted, certificate-based|Unencrypted, PSK or certificate-based encrypted|\-|  ::: noteimportant Connections are unencrypted by default. Encryption must be configured for each host and proxy individually. :::
he	#### ניהול הצפנת חיבור  חיבורים ב- Zabbix יכולים להשתמש ב:  - ללא הצפנה (ברירת מחדל) - [מבוסס תעודת RSA      הצפנה](/manual/encryption/using_certificates) - [הצפנה מבוססת PSK](/manual/encryption/using_pre_shared_keys)  ישנם שני פרמטרים חשובים המשמשים לציון הצפנה ביניהם רכיבי Zabbix:  - TLSConnect - מציין באיזו הצפנה להשתמש עבור יוצאים      חיבורים (לא מוצפנים, PSK או אישור) - TLSAccept - מציין לאילו סוגי חיבורים מותרים      חיבורים נכנסים (לא מוצפנים, PSK או אישור). אחד או יותר      ניתן לציין ערכים.  `TLSConnect` משמש בקבצי התצורה עבור Zabbix proxy (ב מצב פעיל, מציין רק חיבורים לשרת) וסוכן Zabbix (עבור צ'קים פעילים). בחזית Zabbix המקבילה של TLSConnect היא *חיבורים למארח* בשדה *תצורה ← מארחים ← <כמה מארח> → הכרטיסייה הצפנה* והשדה *חיבורים ל-proxy* ב *ניהול ← פרוקסי ← <proxy כלשהו> ← הכרטיסייה הצפנה*. אם ה סוג ההצפנה שהוגדר לחיבור נכשל, אין הצפנה אחרת סוגים ינוסו.  `TLSAccept` משמש בקובצי התצורה עבור Zabbix proxy (ב מצב פסיבי, מציין רק חיבורים מהשרת) וסוכן Zabbix (עבור צ'קים פסיביים). בחזית Zabbix המקבילה של TLSAccept היא *חיבורים מארח* בשדה *תצורה ← מארחים ← <כמה מארח> → הכרטיסייה הצפנה* והשדה *חיבורים מ-proxy* ב *ניהול ← פרוקסי ← <proxy כלשהו> ← הכרטיסייה הצפנה*.  בדרך כלל אתה מגדיר רק סוג אחד של הצפנה עבור נכנסות הצפנות. אבל אולי תרצה לשנות את סוג ההצפנה, למשל. מ לא מוצפן למבוסס אישורים עם מינימום זמן השבתה והחזרה לאחור אפשרות. כדי להשיג זאת:  - הגדר 'TLSAccept=unencrypted,cert' בקובץ התצורה של הסוכן ו      הפעל מחדש את סוכן Zabbix - בדוק את החיבור עם zabbix\_get לסוכן באמצעות אישור. אם      זה עובד, אתה יכול להגדיר מחדש הצפנה עבור הסוכן הזה ב- Zabbix      ממשק קצה ב-*תצורה → מארחים → <מארח כלשהו> →      לשונית הצפנה* על ידי הגדרת *חיבורים למארח* ל"אישור". - כאשר מטמון תצורת השרת מתעדכן (ופרוקסי      התצורה מתעדכנת אם המארח מנוטר על ידי פרוקסי).      החיבורים לאותו סוכן יוצפנו - אם הכל עובד כמצופה אתה יכול להגדיר 'TLSAccept=cert' ב-      קובץ תצורת הסוכן והפעל מחדש את סוכן Zabbix. עכשיו הסוכן      יקבל רק חיבורים מוצפנים מבוססי תעודות.      חיבורים לא מוצפנים ומבוססי PSK יידחו.  באופן דומה זה עובד על שרת ו-proxy. אם ב-Zabix frontend in תצורת המארח *חיבורים מהמארח* מוגדרת ל"אישור" אז רק חיבורים מוצפנים מבוססי תעודה יתקבלו מה- סוכן (צ'קים פעילים) ו-zabbix\_sender (פריטי לוכד).  סביר להניח שתגדיר חיבורים נכנסים ויוצאים לשימוש אותו סוג הצפנה או ללא הצפנה כלל. אבל טכנית זה כן אפשר להגדיר אותו בצורה אסימטרית, למשל. מבוסס תעודה הצפנה עבור נכנסות ומבוססת PSK עבור חיבורים יוצאים.  תצורת ההצפנה עבור כל מארח מוצגת ב- Zabbix חזית, ב-*תצורה → מארחים* בעמודה *הצפנת סוכן*. לדוגמה:  |דוגמה|חיבורים למארח|חיבורים מותרים מהמארח|חיבורים שנדחו מהמארח| |-------|------------------------|------------------------|- ------------------| |![none\_none.png](../../assets/en/manual/encryption/none_none.png)|לא מוצפן|לא מוצפן|מוצפן, תעודה ו-PSK מוצפן| |![cert\_cert.png](../../assets/en/manual/encryption/cert_cert.png)|מוצפן, מבוסס תעודה|מוצפן, מבוסס תעודה|מוצפן לא מוצפן ומבוסס PSK| |![psk\_psk.png](../../assets/en/manual/encryption/psk_psk.png)|מוצפן, מבוסס PSK|מוצפן, מבוסס PSK|מוצפן לא מוצפן ומבוסס תעודות| |![psk\_none\_psk.png](../../assets/en/manual/encryption/psk_none_psk.png)|מוצפן, מבוסס PSK|מוצפן לא מוצפן ומבוסס PSK|מוצפן מבוסס אישור| |![cert\_all.png](../../assets/en/manual/encryption/cert_all.png)|מוצפן, מבוסס תעודה|לא מוצפן, PSK או מבוסס תעודה מוצפן|\-|  ::: שימו לב חשוב חיבורים אינם מוצפנים כברירת מחדל. הצפנה יש להגדיר עבור כל מארח ופרוקסי בנפרד. :::

en-us	### Connection options for Oracle plugin   The Oracle plugin, supported for Zabbix agent 2, now allows to specify `as sysdba`, `as sysoper`, or `as sysasm` login option. The option can be appended either to the user item key parameter or to the plugin configuration parameter Plugins.Oracle.Sessions.<SessionName>.User in the format `user as sysdba` (login option is case-insensitive; must not contain a trailing space).
he	### אפשרויות חיבור עבור תוסף Oracle  התוסף של Oracle, הנתמך עבור Zabbix agent 2, מאפשר כעת לציין 'כ-sysdba', 'כ-sysoper' או 'כ-sysasm' אפשרות התחברות. ניתן לצרף את האפשרות לפרמטר מפתח פריט משתמש או לפרמטר תצורת הפלאגין Plugins.Oracle.Sessions.<SessionName>.User בפורמט `user as sysdba` (אפשרות הכניסה אינה תלוית רישיות; לא חייב להכיל עוקב מֶרחָב).

en-us	### Connection set up  Zabbix supports two types of connect identifiers (connection methods):  -   Easy Connect -   Net Service Name  Connection configuration parameters for Zabbix server and Zabbix proxy can be set in the configuration files. Important parameters for the server and proxy are *DBHost*, *DBUser*, *DBName* and *DBPassword*. The same parameters are important for the frontend: *$DB\["SERVER"\]*, *$DB\["PORT"\]*, *$DB\["DATABASE"\]*, *$DB\["USER"\]*, *$DB\["PASSWORD"\]*.  Zabbix uses the following connection string syntax:      {DBUser/DBPassword[@<connect_identifier>]}   <connect\_identifier> can be specified either in the form of "Net Service Name" or "Easy Connect".      @[[//]Host[:Port]/<service_name> | <net_service_name>]
he	### הגדרת חיבור  Zabbix תומך בשני סוגים של מזהי חיבור (שיטות חיבור):  - חיבור קל - שם שירות נטו  פרמטרים של תצורת חיבור עבור שרת Zabbix ו-Proxy Zabbix ניתן להגדיר בקבצי התצורה. פרמטרים חשובים עבור השרת והפרוקסי הם *DBHost*, *DBUser*, *DBName* ו-*DBPassword*. ה אותם פרמטרים חשובים עבור ה-frontend: *$DB\["SERVER"\]*, *$DB\["PORT"\]*, *$DB\["DATABASE"\]*, *$DB\["USER"\]*, *$DB\["PASSWORD"\]*.  Zabbix משתמש בתחביר מחרוזת החיבור הבא:       {DBUser/DBPassword[@<connect_identifier>]}  ניתן לציין את <connect\_identifier> בצורה של "Net שם שירות" או "חיבור קל".       @[[//]מארח[:פורט]/<שם_שירות> | <net_service_name>]

en-us	#### Copy an LLD rule to multiple hosts  Copy an LLD rule to two hosts.  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.copy",     "params": {         "discoveryids": [             "27426"         ],         "hostids": [             "10196",             "10197"         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": true,     "id": 1 } ```
he	#### העתק כלל LLD למארחים מרובים  העתק כלל LLD לשני מארחים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.copy",      "params": {          "discoveryids": [              "27426"          ],          "hostids": [              "10196",              "10197"          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": נכון,      "מזהה": 1 } ```

en-us	#### Copying/pasting pages  Dashboard pages can be copied and pasted, allowing to create a new page with the properties of an existing one. They can be pasted from the same dashboard or a different dashboard.  To paste an existing page to the dashboard, first copy it, using the [page menu](#page_menu):  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_page_copy.png)  To paste the copied page:  -   Make sure the dashboard is in the [editing     mode](#viewing_and_editing_a_dashboard) -   Click on the arrow next to the *Add* button and select the *Paste     page* option
he	#### העתקה/הדבקה של דפים  ניתן להעתיק ולהדביק דפי לוח מחוונים, מה שמאפשר ליצור עמוד חדש עם המאפיינים של קיים. ניתן להדביק אותם מאותו דבר לוח מחוונים או לוח מחוונים אחר.  כדי להדביק דף קיים ללוח המחוונים, תחילה העתק אותו באמצעות ה- [תפריט עמוד](#page_menu):  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_page_copy.png)  כדי להדביק את הדף שהועתק:  - ודא שלוח המחוונים נמצא ב-[עריכה      mode](#Viewing_and_editing_a_dashboard) - לחץ על החץ שליד כפתור *הוסף* ובחר את *הדבק      אפשרות עמוד*

en-us	#### Copying/pasting widgets  Dashboard widgets can be copied and pasted, allowing to create a new widget with the properties of an existing one. They can be copy-pasted within the same dashboard, or between dashboards opened in different tabs.  A widget can be copied using the [widget menu](#widget_menu). To paste the widget:  -   click on the arrow next to the *Add* button and selecting the *Paste     widget* option, when editing the dashboard -   use the *Paste widget* option when adding a new widget by selecting     some area in the dashboard (a widget must be copied first for the     paste option to become available)  A copied widget can be used to paste over an existing widget using the *Paste* option in the [widget menu](#widget_menu).
he	#### העתקה/הדבקה של ווידג'טים  ניתן להעתיק ולהדביק ווידג'טים של לוח המחוונים, מה שמאפשר ליצור חדש יישומון עם המאפיינים של אחד קיים. ניתן להעתיק אותם בתוך אותו לוח מחוונים, או בין לוחות מחוונים שנפתחו בשונה כרטיסיות.  ניתן להעתיק ווידג'ט באמצעות [תפריט יישומון](#widget_menu). להדביק הווידג'ט:  - לחץ על החץ ליד כפתור *הוסף* ובחר את *הדבק      אפשרות widget*, בעת עריכת לוח המחוונים - השתמש באפשרות *הדבק ווידג'ט* בעת הוספת ווידג'ט חדש על ידי בחירה      אזור כלשהו בלוח המחוונים (יש להעתיק תחילה ווידג'ט עבור      אפשרות הדבקה כדי להפוך לזמינה)  ניתן להשתמש בווידג'ט שהועתק כדי להדביק מעל ווידג'ט קיים באמצעות אפשרות *הדבק* ב[תפריט יישומון](תפריט_widget#).

en-us	##### Copying PHP files  Zabbix frontend is written in PHP, so to run it a PHP supported webserver is needed. Installation is done by simply copying the PHP files from the ui directory to the webserver HTML documents directory.  Common locations of HTML documents directories for Apache web servers include:  -   /usr/local/apache2/htdocs (default directory when installing Apache     from source) -   /srv/www/htdocs (OpenSUSE, SLES) -   /var/www/html (Debian, Ubuntu, Fedora, RHEL)  It is suggested to use a subdirectory instead of the HTML root. To create a subdirectory and copy Zabbix frontend files into it, execute the following commands, replacing the actual directory:      mkdir <htdocs>/zabbix     cd ui     cp -a . <htdocs>/zabbix  If planning to use any other language than English, see [Installation of additional frontend languages](/manual/appendix/install/locales) for instructions.
he	##### העתקת קבצי PHP  החזית של Zabbix כתובה ב-PHP, כך שכדי להפעיל אותו נתמך PHP יש צורך בשרת אינטרנט. ההתקנה מתבצעת על ידי העתקת ה-PHP קבצים מספריית ה-UI לספריית מסמכי HTML של שרת האינטרנט.  מיקומים נפוצים של ספריות מסמכי HTML עבור שרתי אינטרנט של Apache לִכלוֹל:  - /usr/local/apache2/htdocs (ספריית ברירת המחדל בעת התקנת Apache      ממקור) - /srv/www/htdocs (OpenSUSE, SLES) - /var/www/html (Debian, Ubuntu, Fedora, RHEL)  מומלץ להשתמש בספריית משנה במקום בשורש HTML. ל צור ספריית משנה והעתק לתוכה קבצי חזית של Zabbix, הפעל הפקודות הבאות, מחליפות את הספרייה בפועל:       mkdir <htdocs>/zabbix      משתמש תקליטור      רואה חשבון . <htdocs>/zabbix  אם מתכננים להשתמש בכל שפה אחרת מלבד אנגלית, ראה [התקנה של שפות חזית נוספות](/manual/appendix/install/locales) עבור הוראות.

en-us	 ### Copyright notice  Zabbix documentation is NOT distributed under a GPL license. Use  of Zabbix documentation is subject to the following terms:   You may create a printed copy of this documentation solely for your  own personal use. Conversion to other formats is allowed as long as  the actual content is not altered or edited in any way. You shall  not publish or distribute this documentation in any form or on any  media, except if you distribute the documentation in a manner similar  to how Zabbix disseminates it (that is, electronically for download  on a Zabbix web site) or on a USB or similar medium, provided however  that the documentation is disseminated together with the software on  the same medium. Any other use, such as any dissemination of printed  copies or use of this documentation, in whole or in part, in another  publication, requires the prior written consent from an authorized  representative of Zabbix. Zabbix reserves any and all rights to this  documentation not expressly granted above.
he	### הודעת זכויות יוצרים  תיעוד Zabbix אינו מופץ תחת רישיון GPL. להשתמש של תיעוד Zabbix כפוף לתנאים הבאים:  אתה רשאי ליצור עותק מודפס של תיעוד זה אך ורק עבורך שימוש אישי משלו. המרה לפורמטים אחרים מותרת כל עוד התוכן בפועל אינו משתנה או נערך בשום אופן. אתה תעשה לא לפרסם או להפיץ תיעוד זה בשום צורה או בכל צורה שהיא מדיה, למעט אם אתה מפיץ את התיעוד באופן דומה לאופן שבו Zabbix מפיץ אותו (כלומר, אלקטרונית להורדה באתר אינטרנט של Zabbix) או ב-USB או מדיום דומה, עם זאת שהתיעוד מופץ יחד עם התוכנה על אותו מדיום. כל שימוש אחר, כגון כל הפצה של מודפס עותקים או שימוש בתיעוד זה, כולו או חלקו, באחר פרסום, מצריך הסכמה מראש ובכתב מאת מורשה נציג של Zabbix. Zabbix שומרת לעצמה את כל הזכויות על כך תיעוד שלא ניתן במפורש לעיל.

en-us	# correlation.create
he	# קורלציה.צור

en-us	# correlation.delete
he	# קורלציה.מחיקה

en-us	#### Correlation filter condition  The correlation filter condition object defines a specific condition that must be checked before running the correlation operations.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**type**<br>(required)|integer|Type of condition.<br><br>Possible values:<br>0 - old event tag;<br>1 - new event tag;<br>2 - new event host group;<br>3 - event tag pair;<br>4 - old event tag value;<br>5 - new event tag value.| |tag|string|Event tag (old or new). Required when type of condition is: 0, 1, 4, 5.| |groupid|string|Host group ID. Required when type of condition is: 2.| |oldtag|string|Old event tag. Required when type of condition is: 3.| |newtag|string|New event tag. Required when type of condition is: 3.| |value|string|Event tag (old or new) value. Required when type of condition is: 4, 5.| |formulaid|string|Arbitrary unique ID that is used to reference the condition from a custom expression. Can only contain capital-case letters. The ID must be defined by the user when modifying filter conditions, but will be generated anew when requesting them afterward.| |operator|integer|Condition operator.<br><br>Required when type of condition is: 2, 4, 5.|  ::: notetip To better understand how to use filters with various types of expressions, see examples on the [correlation.get](get#retrieve_correlations) and [correlation.create](create#using_a_custom_expression_filter) method pages. :::  The following operators and values are supported for each condition type.  |Condition|Condition name|Supported operators|Expected value| |---------|--------------|-------------------|--------------| |2|Host group|=, <>|Host group ID.| |4|Old event tag value|=, <>, like, not like|string| |5|New event tag value|=, <>, like, not like|string|
he	#### מצב מסנן מתאם  אובייקט תנאי מסנן המתאם מגדיר תנאי ספציפי שיש לבדוק לפני הפעלת פעולות המתאם.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**סוג**<br>(נדרש)|מספר שלם|סוג המצב.<br><br>ערכים אפשריים:<br>0 - תג אירוע ישן;<br>1 - תג אירוע חדש;<br>2 - קבוצת מארח אירוע חדשה;<br>3 - זוג תג אירוע;<br>4 - ערך תג אירוע ישן;<br>5 - ערך תג אירוע חדש.| |tag|string|תג אירוע (ישן או חדש). נדרש כאשר סוג התנאי הוא: 0, 1, 4, 5.| |groupid|string|מזהה קבוצת מארח. נדרש כאשר סוג התנאי הוא: 2.| |oldtag|string|תג אירוע ישן. נדרש כאשר סוג התנאי הוא: 3.| |newtag|string|תג אירוע חדש. נדרש כאשר סוג התנאי הוא: 3.| |value|string|ערך תג אירוע (ישן או חדש). נדרש כאשר סוג התנאי הוא: 4, 5.| |formulaid|string|מזהה ייחודי שרירותי המשמש להפניה לתנאי מביטוי מותאם אישית. יכול להכיל רק אותיות רישיות. המזהה חייב להיות מוגדר על ידי המשתמש בעת שינוי תנאי הסינון, אך יופק מחדש בעת בקשתם לאחר מכן.| |operator|integer|אופרטור תנאי.<br><br>נדרש כאשר סוג התנאי הוא: 2, 4, 5.|  ::: הערה כדי להבין טוב יותר כיצד להשתמש במסננים עם שונים סוגי ביטויים, ראה דוגמאות על [correlation.get](get#retrieve_correlations) ו שיטת [correlation.create](create#using_a_custom_expression_filter). דפים. :::  האופרטורים והערכים הבאים נתמכים עבור כל תנאי סוּג.  |מצב|שם תנאי|אופרטורים נתמכים|ערך צפוי| |--------|--------------|----------------|---- ----------| |2|קבוצת מארח|=, <>|מזהה קבוצת מארח.| |4|ערך תג אירוע ישן|=, <>, like, not like|string| |5|ערך תג אירוע חדש|=, <>, like, not like|string|

en-us	### Correlation filter  The correlation filter object defines a set of conditions that must be met to perform the configured correlation operations. It has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**evaltype**<br>(required)|integer|Filter condition evaluation method.<br><br>Possible values:<br>0 - and/or;<br>1 - and;<br>2 - or;<br>3 - custom expression.| |**conditions**<br>(required)|array|Set of filter conditions to use for filtering results.| |eval\_formula|string|*(readonly)* Generated expression that will be used for evaluating filter conditions. The expression contains IDs that reference specific filter conditions by its `formulaid`. The value of `eval_formula` is equal to the value of `formula` for filters with a custom expression.| |formula|string|User-defined expression to be used for evaluating conditions of filters with a custom expression. The expression must contain IDs that reference specific filter conditions by its `formulaid`. The IDs used in the expression must exactly match the ones defined in the filter conditions: no condition can remain unused or omitted.<br><br>Required for custom expression filters.|
he	### מסנן מתאם  אובייקט מסנן המתאם מגדיר קבוצה של תנאים שחייבים להיות נפגש כדי לבצע את פעולות המתאם המוגדרות. יש לו את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**evaltype**<br>(חובה)|מספר שלם|שיטת הערכת מצב מסנן.<br><br>ערכים אפשריים:<br>0 - ו/או;<br>1 - ו;<br>2 - או;<br>3 - ביטוי מותאם אישית.| |**תנאים**<br>(חובה)|מערך|סט של תנאי סינון לשימוש לסינון תוצאות.| |eval\_formula|string|*(לקריאה בלבד)* ביטוי שנוצר שישמש להערכת תנאי סינון. הביטוי מכיל מזהים שמתייחסים לתנאי סינון ספציפיים לפי ה'נוסחה' שלו. הערך של `eval_formula` שווה לערך של `נוסחה` עבור מסננים עם ביטוי מותאם אישית.| |formula|string|ביטוי מוגדר על ידי משתמש לשימוש להערכת תנאים של מסננים עם ביטוי מותאם אישית. הביטוי חייב להכיל מזהים שמתייחסים לתנאי סינון ספציפיים לפי ה'נוסחה' שלו. המזהים המשמשים בביטוי חייבים להתאים בדיוק לאלו שהוגדרו בתנאי הסינון: אין אפשרות להישאר ללא שימוש או להשמיט שום תנאי.<br><br>נדרש עבור מסנני ביטויים מותאמים אישית.|

en-us	# correlation.get
he	# correlation.get

en-us	# > Correlation object  The following objects are directly related to the `correlation` API.
he	# > עצם יחס  העצמים הבאים קשורים ישירות ל־API‏ `correlation`.

en-us	### Correlation operation  The correlation operation object defines an operation that will be performed when a correlation is executed. It has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**type**<br>(required)|integer|Type of operation.<br><br>Possible values:<br>0 - close old events;<br>1 - close new event.|
he	### פעולת מתאם  אובייקט פעולת המתאם מגדיר פעולה שתהיה מבוצע כאשר מתבצעת מתאם. יש לו את הדברים הבאים נכסים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**סוג**<br>(נדרש)|מספר שלם|סוג הפעולה.<br><br>ערכים אפשריים:<br>0 - סגור אירועים ישנים;<br>1 - סגור אירוע חדש.|

en-us	### Correlation  The correlation object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |correlationid|string|*(readonly)* ID of the correlation.| |**name**<br>(required)|string|Name of the correlation.| |description|string|Description of the correlation.| |status|integer|Whether the correlation is enabled or disabled.<br><br>Possible values are:<br>0 - *(default)* enabled;<br>1 - disabled.|  Note that for some methods (update, delete) the required/optional parameter combination is different.
he	### מתאם  לאובייקט המתאם יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |correlationid|string|*(קריאה בלבד)* מזהה המתאם.| |**שם**<br>(חובה)|מחרוזת|שם המתאם.| |description|string|תיאור המתאם.| |status|integer|האם המתאם מופעל או מושבת.<br><br>ערכים אפשריים הם:<br>0 - *(ברירת מחדל)* מופעלת;<br>1 - מושבת.|  שימו לב שעבור שיטות מסוימות (עדכון, מחק) שילוב הפרמטרים הנדרש/אופציונלי שונה.

en-us	# Correlation  This class is designed to work with correlations.  Object references:\  -   [Correlation](/manual/api/reference/correlation/object#correlation)  Available methods:\  -   [correlation.create](/manual/api/reference/correlation/create) -     creating new correlations -   [correlation.delete](/manual/api/reference/correlation/delete) -     deleting correlations -   [correlation.get](/manual/api/reference/correlation/get) -     retrieving correlations -   [correlation.update](/manual/api/reference/correlation/update) -     updating correlations
he	# יחס  מחלקה זו תוכננה לעבוד עם יחסים.  סימוכין לפריט:\  -   [יחס](/manual/api/reference/correlation/object#correlation)  מתודות זמינות:\  -   [correlation.create](/manual/api/reference/correlation/create) -     יצירת יחסים חדשים -   [correlation.delete](/manual/api/reference/correlation/delete) -     מחיקת יחסים -   [correlation.get](/manual/api/reference/correlation/get) -     משיכת יחסים -   [correlation.update](/manual/api/reference/correlation/update) -     עדכון יחסים

en-us	# correlation.update
he	# עדכון.מתאם

en-us	##### Counting of threads in `proc.mem[]` and `proc.num[]` items  Linux kernel threads are counted by `proc.num[]` item but do not report memory in `proc.mem[]` item. For example:      $ ps -ef | grep kthreadd     root         2     0  0 09:51 ?        00:00:00 [kthreadd]      $ zabbix_get -s localhost -k 'proc.num[kthreadd]'     1      $ zabbix_get -s localhost -k 'proc.mem[kthreadd]'     ZBX_NOTSUPPORTED: Cannot get amount of "VmSize" memory.  But what happens if there is a user process with the same name as a kernel thread ? Then it could look like this:      $ ps -ef | grep kthreadd     root         2     0  0 09:51 ?        00:00:00 [kthreadd]     zabbix    9611  6133  0 17:58 pts/1    00:00:00 ./kthreadd      $ zabbix_get -s localhost -k 'proc.num[kthreadd]'     2      $ zabbix_get -s localhost -k 'proc.mem[kthreadd]'     4157440  `proc.num[]` counted both the kernel thread and the user process. `proc.mem[]` reports memory for the user process only and counts the kernel thread memory as if it was 0. This is different from the case above when ZBX\_NOTSUPPORTED was reported.  Be careful when using `proc.mem[]` and `proc.num[]` items if the program name happens to match one of the thread.  Before putting parameters into `proc.mem[]` and `proc.num[]` items, you may want to test the parameters using `proc.num[]` item and `ps` command.
he	##### ספירת שרשורים בפריטי `proc.mem[]` ו-`proc.num[]`  שרשורי ליבת לינוקס נספרים לפי פריט `proc.num[]` אך אינם מדווחים זיכרון בפריט `proc.mem[]`. לדוגמה:       $ ps -ef | grep kthreadd      שורש 2 0 0 09:51 ? 00:00:00 [kthreadd]       $ zabbix_get -s localhost -k 'proc.num[kthreadd]'      1       $ zabbix_get -s localhost -k 'proc.mem[kthreadd]'      ZBX_NOTSUPPORTED: לא ניתן לקבל כמות זיכרון "VmSize".  אבל מה קורה אם יש תהליך משתמש באותו שם כמו א חוט ליבה? ואז זה יכול להיראות כך:       $ ps -ef | grep kthreadd      שורש 2 0 0 09:51 ? 00:00:00 [kthreadd]      zabbix 9611 6133 0 17:58 נקודות/1 00:00:00 ./kthreadd       $ zabbix_get -s localhost -k 'proc.num[kthreadd]'      2       $ zabbix_get -s localhost -k 'proc.mem[kthreadd]'      4157440  `proc.num[]` ספר גם את שרשור הליבה וגם את תהליך המשתמש. `proc.mem[]` מדווח על זיכרון עבור תהליך המשתמש בלבד וסופר את זיכרון פתיל ליבה כאילו הוא 0. זה שונה מהמקרה לעיל כאשר דווח על ZBX\_NOTSUPPORTED.  היזהר בעת שימוש בפריטים `proc.mem[]` ו-`proc.num[]` אם התוכנית שם במקרה תואם לאחד מהשרשור.  לפני שמכניסים פרמטרים לפריטים `proc.mem[]` ו-`proc.num[]`, אתה אולי תרצה לבדוק את הפרמטרים באמצעות הפריט `proc.num[]` ו-`ps` פקודה.

en-us	**CPU**  Zabbix and especially Zabbix database may require significant CPU resources depending on number of monitored parameters and chosen database engine.
he	**מעבד**  Zabbix ובמיוחד מסד נתונים Zabbix עשויים לדרוש מעבד משמעותי משאבים בהתאם למספר הפרמטרים המנוטרים והנבחרים מנוע מסד נתונים.

en-us	#### Create a custom script  Create a custom script that will reboot a server. The script will require write access to the host and will display a configuration message before running in the frontend.  Request:  ```json {     "jsonrpc": "2.0",     "method": "script.create",     "params": {         "name": "Reboot server",         "command": "reboot server 1",         "confirmation": "Are you sure you would like to reboot the server?",         "scope": 2,         "type": 0     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "scriptids": [             "4"         ]     },     "id": 1 } ```
he	#### צור סקריפט מותאם אישית  צור סקריפט מותאם אישית שיאתחל מחדש שרת. התסריט יהיה דורש גישת כתיבה למארח ויציג תצורה הודעה לפני ריצה ב-frontend.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "script.create",      "params": {          "name": "אתחל שרת",          "command": "אתחול מחדש של שרת 1",          "confirmation": "האם אתה בטוח שברצונך לאתחל את השרת?",          "היקף": 2,          "סוג": 0      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "scriptids": [              "4"          ]      },      "מזהה": 1 } ```

en-us	#### Create a discovery action  Create a discovery action that will link discovered hosts to template "10001".  Request:  ```json {     "jsonrpc": "2.0",     "method": "action.create",     "params": {         "name": "Discovery action",         "eventsource": 1,         "filter": {             "evaltype": 0,             "conditions": [                 {                     "conditiontype": 21,                     "operator": 0,                     "value": "1"                 },                 {                     "conditiontype": 10,                     "operator": 0,                     "value": "2"                 }             ]         },         "operations": [             {                 "operationtype": 6,                 "optemplate": [                     {                         "templateid": "10001"                     }                 ]             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "actionids": [             "18"         ]     },     "id": 1 } ```
he	#### צור פעולת גילוי  צור פעולת גילוי שתקשר מארחים שהתגלו לתבנית "10001".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "action.create",      "params": {          "name": "פעולת גילוי",          "מקור אירועים": 1,          "מסנן": {              "evaltype": 0,              "תנאים": [                  {                      "סוג מצב": 21,                      "מפעיל": 0,                      "value": "1"                  },                  {                      "סוג מצב": 10,                      "מפעיל": 0,                      "value": "2"                  }              ]          },          "פעולות": [              {                  "סוג פעולה": 6,                  "optemplate": [                      {                          "templateid": "10001"                      }                  ]              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "actionids": [              "18"          ]      },      "מזהה": 1 } ```

en-us	#### Create a discovery rule  Create a discovery rule to find machines running the Zabbix agent in the local network. The rule must use a single Zabbix agent check on port 10050.  Request:  ```json {     "jsonrpc": "2.0",     "method": "drule.create",     "params": {         "name": "Zabbix agent discovery",         "iprange": "192.168.1.1-255",         "dchecks": [             {                 "type": "9",                 "key_": "system.uname",                 "ports": "10050",                 "uniq": "0"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "druleids": [             "6"         ]     },     "id": 1 } ```
he	#### צור כלל גילוי  צור כלל גילוי כדי למצוא מכונות המרצות את סוכן Zabbix ב- רשת מקומית. הכלל חייב להשתמש בבדיקת סוכן אחת של Zabbix ביציאה 10050.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "drule.create",      "params": {          "name": "גילוי סוכן Zabbix",          "iprange": "192.168.1.1-255",          "dchecks": [              {                  "type": "9",                  "key_": "system.uname",                  "ports": "10050",                  "uniq": "0"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "דרולידס": [              "6"          ]      },      "מזהה": 1 } ```

en-us	#### Create agent autoregistration rule  Create an autoregistration action that adds a host to host group "2" when the host name contains "SRV" or metadata contains "AlmaLinux".  Request:  ```json {     "jsonrpc": "2.0",     "method": "action.create",     "params": {         "name": "Register Linux servers",         "eventsource": "2",         "filter": {             "evaltype": "2",             "conditions": [                 {                     "conditiontype": "22",                     "operator": "2",                     "value": "SRV"                 },                 {                     "conditiontype": "24",                     "operator": "2",                     "value": "AlmaLinux"                 }             ]         },         "operations": [             {                 "operationtype": "4",                 "opgroup": [                     {                         "groupid": "2"                     }                 ]             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "actionids": [             19         ]     },     "id": 1 } ```
he	#### צור כלל רישום אוטומטי של סוכן  צור פעולת רישום אוטומטי שמוסיפה מארח לקבוצת המארח "2" כאשר שם המארח מכיל "SRV" או מטא נתונים מכילים "AlmaLinux".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "action.create",      "params": {          "name": "רשום שרתי לינוקס",          "eventsource": "2",          "מסנן": {              "evaltype": "2",              "תנאים": [                  {                      "conditiontype": "22",                      "מפעיל": "2",                      "value": "SRV"                  },                  {                      "conditiontype": "24",                      "מפעיל": "2",                      "value": "AlmaLinux"                  }              ]          },          "פעולות": [              {                  "operationtype": "4",                  "opgroup": [                      {                          "groupid": "2"                      }                  ]              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "actionids": [              19          ]      },      "מזהה": 1 } ```

en-us	#### Create a host map  Create a map with two host elements and a link between them. Note the use of temporary "selementid1" and "selementid2" values in the map link object to refer to map elements.  Request:  ```json {     "jsonrpc": "2.0",     "method": "map.create",     "params": {         "name": "Host map",         "width": 600,         "height": 600,         "selements": [             {                 "selementid": "1",                 "elements": [                     {"hostid": "1033"}                 ],                 "elementtype": 0,                 "iconid_off": "2"             },              {                 "selementid": "2",                 "elements": [                     {"hostid": "1037"}                 ],                 "elementtype": 0,                 "iconid_off": "2"             }         ],         "links": [             {                 "selementid1": "1",                 "selementid2": "2"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "sysmapids": [             "9"         ]     },     "id": 1 } ```
he	#### צור מפת מארח  צור מפה עם שני אלמנטים מארח וקישור ביניהם. שימו לב ל שימוש בערכי "selementid1" ו-"selementid2" זמניים בקישור המפה אובייקט להתייחס לרכיבי מפה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "map.create",      "params": {          "name": "מפת מארח",          "רוחב": 600,          "גובה": 600,          "אלמנטים": [              {                  "selementid": "1",                  "אלמנטים": [                      {"hostid": "1033"}                  ],                  "elementtype": 0,                  "iconid_off": "2"              },               {                  "selementid": "2",                  "אלמנטים": [                      {"hostid": "1037"}                  ],                  "elementtype": 0,                  "iconid_off": "2"              }          ],          "קישורים": [              {                  "selementid1": "1",                  "selementid2": "2"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "sysmapids": [              "9"          ]      },      "מזהה": 1 } ```

en-us	#### Create an active proxy  Create an action proxy "Active proxy" and assign a host to be monitored by it.  Request:  ```json {     "jsonrpc": "2.0",     "method": "proxy.create",     "params": {         "host": "Active proxy",         "status": "5",         "hosts": [             {                 "hostid": "10279"             }         ]     },     "auth": "ab9638041ec6922cb14b07982b268f47",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "proxyids": [             "10280"         ]     },     "id": 1 } ```
he	#### צור פרוקסי פעיל  צור פרוקסי פעולה "פרוקסי פעיל" והקצה מארח למעקב על ידי זה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "proxy.create",      "params": {          "host": "פרוקסי פעיל",          "status": "5",          "מארחים": [              {                  "hostid": "10279"              }          ]      },      "auth": "ab9638041ec6922cb14b07982b268f47",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "proxyids": [              "10280"          ]      },      "מזהה": 1 } ```

en-us	#### Create an empty map  Create a map with no elements.  Request:  ```json {     "jsonrpc": "2.0",     "method": "map.create",     "params": {         "name": "Map",         "width": 600,         "height": 600     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "sysmapids": [             "8"         ]     },     "id": 1 } ```
he	#### צור מפה ריקה  צור מפה ללא אלמנטים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "map.create",      "params": {          "name": "מפה",          "רוחב": 600,          "גובה": 600      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "sysmapids": [              "8"          ]      },      "מזהה": 1 } ```

en-us	#### Create a new event tag correlation  Create a correlation using evaluation method `AND/OR` with one condition and one operation. By default the correlation will be enabled.  Request:  ```json {     "jsonrpc": "2.0",     "method": "correlation.create",     "params": {         "name": "new event tag correlation",         "filter": {             "evaltype": 0,             "conditions": [                 {                     "type": 1,                     "tag": "ok"                 }             ]         },         "operations": [             {                 "type": 0             }         ]     },     "auth": "343baad4f88b4106b9b5961e77437688",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "correlationids": [             "1"         ]     },     "id": 1 } ```
he	#### צור מתאם חדש של תג אירוע  צור מתאם באמצעות שיטת הערכה 'AND/OR' עם תנאי אחד וניתוח אחד. כברירת מחדל, הקורלציה תהיה מופעלת.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "correlation.create",      "params": {          "name": "מתאם חדש של תג אירוע",          "מסנן": {              "evaltype": 0,              "תנאים": [                  {                      "סוג 1,                      "תג": "בסדר"                  }              ]          },          "פעולות": [              {                  "סוג": 0              }          ]      },      "auth": "343baad4f88b4106b9b5961e77437688",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "Correlationids": [              "1"          ]      },      "מזהה": 1 } ```

en-us	#### Create a new interface  Create a secondary IP agent interface on host "30052."  Request:  ```json {     "jsonrpc": "2.0",     "method": "hostinterface.create",     "params": {         "hostid": "30052",         "main": "0",         "type": "1",         "useip": "1",         "ip": "127.0.0.1",         "dns": "",         "port": "10050",     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "interfaceids": [             "30062"         ]     },     "id": 1 } ```
he	#### צור ממשק חדש  צור ממשק סוכן IP משני במארח "30052".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "hostinterface.create",      "params": {          "hostid": "30052",          "main": "0",          "סוג 1",          "useip": "1",          "ip": "127.0.0.1",          "dns": "",          "port": "10050",      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "interfaceids": [              "30062"          ]      },      "מזהה": 1 } ```

en-us	#### Create an icon map  Create an icon map to display hosts of different types.  Request:  ```json {     "jsonrpc": "2.0",     "method": "iconmap.create",     "params": {         "name": "Type icons",         "default_iconid": "2",         "mappings": [             {                 "inventory_link": 1,                 "expression": "server",                 "iconid": "3"             },             {                 "inventory_link": 1,                 "expression": "switch",                 "iconid": "4"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "iconmapids": [             "2"         ]     },     "id": 1 } ```
he	#### צור מפת אייקונים  צור מפת אייקונים כדי להציג מארחים מסוגים שונים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "iconmap.create",      "params": {          "name": "הקלד סמלים",          "default_iconid": "2",          "מיפויים": [              {                  "קישור_מלאי": 1,                  "expression": "שרת",                  "iconid": "3"              },              {                  "קישור_מלאי": 1,                  "expression": "מתג",                  "iconid": "4"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "iconmapids": [              "2"          ]      },      "מזהה": 1 } ```

en-us	#### Create an image  Create a cloud icon.  Request:  ```json {     "jsonrpc": "2.0",     "method": "image.create",     "params": {         "imagetype": 1,         "name": "Cloud_(24)",         "image": "iVBORw0KGgoAAAANSUhEUgAAABgAAAANCAYAAACzbK7QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACmAAAApgBNtNH3wAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIcSURBVDjLrZLbSxRRHMdPKiEiRQ89CD0s+N5j9BIMEf4Hg/jWexD2ZEXQbC9tWUFZimtLhswuZiVujK1UJmYXW9PaCUdtb83enL3P7s6ss5f5dc7EUsmqkPuFH3M4/Ob7+V0OAgC0UyDENFEU03rh1uNOs/lFG75o2i2/rkd9Y3Tgyj3HiaezbukdH9A/rP4E9vWi0u+Y4fuGnMf3DRgYc3Z/84YrQSkD3mgKhFAC+KAEK74Y2Lj3MjPoOokQ3Xyx/1GHeXCifbfO6lRPH/wi+AvZQhGSsgKxdB5CCRkCGPbDgMXBMbukTc4vK5/WRHizsq7fZl2LFuvE4T0BZDTXHtgv4TNUqlUolsqQL2qQwbDEXzBBTIJ7I4y/cfAENmHZF4XrY9Mc+X9HAFmoyXS2ddy1IOg6/KNyBcM0DFP/wFZFCcOy4N9Mw0YkCTOfhdL5AfZQXQBFn2t/ODXHC8FYVcoWjNEQ03qqwTJ5FdI44jg/msoB2Zd5ZKq3q6evA1FUS60bYyyj3AJf3V72HiLZJQxTtRLk1C2IYEg4mTNg63hPd1mOJd7Ict911OMNlWEf0nFxpCt16zcshTuLpGSwDDuPIfv0xzNyQYVGicC0cgUUDLM6Xp02lvvW/V2EBssnxlSGmWsxljw0znV9XfPLjTCW84r+cn7Jc8c2eWrbM6Wbe6/aTJbhJ/TNkWc9/xXW592Xb9iPkKnUfH8BKdLgFy0lDyQAAAAASUVORK5CYII="     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "imageids": [             "188"         ]     },     "id": 1 } ```
he	#### צור תמונה  צור סמל ענן.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "image.create",      "params": {          "imagetype": 1,          "name": "Cloud_(24)",          /aTJbhJ/TNkWc9/xXW592Xb9iPkKnUfH8BKdLgFy0lDyQAAAAASUVORK5CYII="      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "imageids": [              "188"          ]      },      "מזהה": 1 } ```

en-us	#### Create an interface with SNMP details  Request:  ```json {     "jsonrpc": "2.0",     "method": "hostinterface.create",     "params": {         "hostid": "10456",         "main": "0",         "type": "2",         "useip": "1",         "ip": "127.0.0.1",         "dns": "",         "port": "1601",         "details": {             "version": "2",             "bulk": "1",             "community": "{$SNMP_COMMUNITY}"         }     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "interfaceids": [             "30063"         ]     },     "id": 1 } ```
he	#### צור ממשק עם פרטי SNMP  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "hostinterface.create",      "params": {          "hostid": "10456",          "main": "0",          "type": "2",          "useip": "1",          "ip": "127.0.0.1",          "dns": "",          "port": "1601",          "פרטים": {              "גרסה 2",              "bulk": "1",              "קהילה": "{$SNMP_COMMUNITY}"          }      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "interfaceids": [              "30063"          ]      },      "מזהה": 1 } ```

en-us	 Create another child service of Zabbix cluster with name "Zabbix server node 2".   Set the Problem tags as:   - Name: component - Operation: Equals - Value: HA node 2  Switch to the *Tags* tab and add a service tag: `Zabbix server:node 2`.  Save the new service. 
he	צור שירות ילד נוסף של אשכול Zabbix עם השם "צומת שרת Zabbix 2".  הגדר את תגי הבעיה כ:  - שם: רכיב - תפעול: שווה - ערך: צומת HA 2  עבור ללשונית *תגים* והוסף תג שירות: `Zabbix server:node 2`.  שמור את השירות החדש.

en-us	#### Create an SSH script  Create an SSH script with public key authentication that can be executed on a host and has a context menu.  Request:  ```json {     "jsonrpc": "2.0",     "method": "script.create",     "params": {         "name": "SSH script",         "command": "my script command",         "type": 2,         "username": "John",         "publickey": "pub.key",         "privatekey": "priv.key",         "password": "secret",         "port": "12345",         "scope": 2,         "menu_path": "All scripts/SSH",         "usrgrpid": "7",         "groupid": "4"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "scriptids": [             "5"         ]     },     "id": 1 } ```
he	#### צור סקריפט SSH  צור סקריפט SSH עם אימות מפתח ציבורי שניתן להפעיל על מארח ויש לו תפריט הקשר.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "script.create",      "params": {          "name": "סקריפט SSH",          "command": "פקודת הסקריפט שלי",          "סוג": 2,          "username": "ג'ון",          "publickey": "pub.key",          "privatekey": "priv.key",          "סיסמה": "סוד",          "port": "12345",          "היקף": 2,          "menu_path": "כל הסקריפטים/SSH",          "usrgrpid": "7",          "groupid": "4"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "scriptids": [              "5"          ]      },      "מזהה": 1 } ```

en-us	#### Create a passive proxy  Create a passive proxy "Passive proxy" and assign two hosts to be monitored by it.  Request:  ```json {     "jsonrpc": "2.0",     "method": "proxy.create",     "params": {         "host": "Passive proxy",         "status": "6",         "interface": {             "ip": "127.0.0.1",             "dns": "",             "useip": "1",             "port": "10051"         },         "hosts": [             {                 "hostid": "10192"             },             {                 "hostid": "10139"             }         ]     },     "auth": "ab9638041ec6922cb14b07982b268f47",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "proxyids": [             "10284"         ]     },     "id": 1 } ```
he	#### צור פרוקסי פסיבי  צור פרוקסי פסיבי "פרוקסי פסיבי" והקצה שני מארחים להיות מפוקח על ידו.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "proxy.create",      "params": {          "host": "פרוקסי פסיבי",          "status": "6",          "ממשק": {              "ip": "127.0.0.1",              "dns": "",              "useip": "1",              "port": "10051"          },          "מארחים": [              {                  "hostid": "10192"              },              {                  "hostid": "10139"              }          ]      },      "auth": "ab9638041ec6922cb14b07982b268f47",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "proxyids": [              "10284"          ]      },      "מזהה": 1 } ```

en-us	#### Create a token  Create an enabled token that never expires and authenticates user of ID 2.  Request:  ```json {     "jsonrpc": "2.0",     "method": "token.create",     "params": {         "name": "Your token",         "userid": "2"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "tokenids": [             "188"         ]     },     "id": 1 } ```  Create a disabled token that expires at January 21st, 2021. This token will authenticate current user.  Request:  ```json {     "jsonrpc": "2.0",     "method": "token.create",     "params": {         "name": "Your token",         "status": "1",         "expires_at": "1611238072"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "tokenids": [             "189"         ]     },     "id": 1 } ```
he	#### צור אסימון  צור אסימון מאופשר שלעולם לא יפוג ומאמת את משתמש המזהה 2.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "token.create",      "params": {          "name": "האסימון שלך",          "userid": "2"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "אסימונים": [              "188"          ]      },      "מזהה": 1 } ```  צור אסימון מושבת שיפוג ב-21 בינואר 2021. אסימון זה יאמת את המשתמש הנוכחי.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "token.create",      "params": {          "name": "האסימון שלך",          "status": "1",          "expires_at": "1611238072"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "אסימונים": [              "189"          ]      },      "מזהה": 1 } ```

en-us	#### Create a trigger action  Create a trigger action that will begin once a trigger (with the word "memory" in its name) from host "10084" goes into a PROBLEM state. The action will have 4 configured operations. The first and immediate operation will send a message to all users in user group "7" via media type "1". If the event is not resolved in 30 minutes, the second operation will run [script](/manual/web_interface/frontend_sections/administration/scripts#configuring-a-global-script) "5" (script with scope "Action operation") on all hosts in group "2". If the event is resolved, a recovery operation will notify all users who received any messages regarding the problem. If the event is updated, an acknowledge/update operation will notify (with a custom subject and message) all users who received any messages regarding the problem.  Request:  ```json {     "jsonrpc": "2.0",     "method": "action.create",     "params": {         "name": "Trigger action",         "eventsource": 0,         "esc_period": "30m",         "filter": {             "evaltype": 0,             "conditions": [                 {                     "conditiontype": 1,                     "operator": 0,                     "value": "10084"                 },                 {                     "conditiontype": 3,                     "operator": 2,                     "value": "memory"                 }             ]         },         "operations": [             {                 "operationtype": 0,                 "esc_step_from": 1,                 "esc_step_to": 1,                 "opmessage_grp": [                     {                         "usrgrpid": "7"                     }                 ],                 "opmessage": {                     "default_msg": 1,                     "mediatypeid": "1"                 }             },             {                 "operationtype": 1,                 "esc_step_from": 2,                 "esc_step_to": 2,                 "opconditions": [                     {                         "conditiontype": 14,                         "operator": 0,                         "value": "0"                     }                 ],                 "opcommand_grp": [                     {                         "groupid": "2"                     }                 ],                 "opcommand": {                     "scriptid": "5"                 }             }         ],         "recovery_operations": [             {                 "operationtype": "11",                 "opmessage": {                     "default_msg": 1                 }             }             ],         "update_operations": [             {                 "operationtype": "12",                 "opmessage": {                     "default_msg": 0,                     "message": "Custom update operation message body",                     "subject": "Custom update operation message subject"                 }             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "actionids": [             "17"         ]     },     "id": 1 } ```
he	#### צור פעולת טריגר  צור פעולת טריגר שתתחיל ברגע שטריגר (עם המילה "זיכרון" בשמה) מהמארח "10084" נכנס למצב PROBLEM. לפעולה יהיו 4 פעולות מוגדרות. הפעולה הראשונה והמיידית תשלח הודעה לכל המשתמשים בקבוצת המשתמש "7" באמצעות מדיה מסוג "1". אם האירוע לא ייפתר תוך 30 דקות, הפעולה השנייה תפעיל את [script](/manual/web_interface/frontend_sections/administration/scripts#configuring-a-global-script) "5" (סקריפט עם היקף "פעולת פעולה") על כל המארחים בקבוצה "2". אם האירוע נפתר, פעולת שחזור תודיע לכל המשתמשים שקיבלו הודעות כלשהן בנוגע לבעיה. אם האירוע מתעדכן, פעולת אישור/עדכון תודיע (עם נושא והודעה מותאמת אישית) לכל המשתמשים שקיבלו הודעות כלשהן בנוגע לבעיה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "action.create",      "params": {          "name": "פעולת טריגר",          "מקור אירועים": 0,          "esc_period": "30 מ'",          "מסנן": {              "evaltype": 0,              "תנאים": [                  {                      "סוג מצב": 1,                      "מפעיל": 0,                      "value": "10084"                  },                  {                      "סוג מצב": 3,                      "מפעיל": 2,                      "value": "זיכרון"                  }              ]          },          "פעולות": [              {                  "סוג פעולה": 0,                  "esc_step_from": 1,                  "esc_step_to": 1,                  "opmessage_grp": [                      {                          "usrgrpid": "7"                      }                  ],                  "opmessage": {                      "default_msg": 1,                      "mediatypeid": "1"                  }              },              {                  "סוג פעולה": 1,                  "esc_step_from": 2,                  "esc_step_to": 2,                  "תנאים אופקיים": [                      {                          "סוג מצב": 14,                          "מפעיל": 0,                          "value": "0"                      }                  ],                  "opcommand_grp": [                      {                          "groupid": "2"                      }                  ],                  "opcommand": {                      "scriptid": "5"                  }              }          ],          "פעולות_שחזור": [              {                  "operationtype": "11",                  "opmessage": {                      "default_msg": 1                  }              }          ],          "עדכון_פעולות": [              {                  "operationtype": "12",                  "opmessage": {                      "default_msg": 0,                      "message": "גוף הודעת פעולת עדכון מותאם אישית",                      "subject": "נושא הודעת פעולת עדכון מותאם אישית"                  }              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "actionids": [              "17"          ]      },      "מזהה": 1 } ```

en-us	#### Create a trigger map  Create a map with trigger element, which contains two triggers.  Request:  ```json {     "jsonrpc": "2.0",     "method": "map.create",     "params": {         "name": "Trigger map",         "width": 600,         "height": 600,         "selements": [             {                 "elements": [                     {"triggerid": "12345"},                     {"triggerid": "67890"}                 ],                 "elementtype": 2,                 "iconid_off": "2"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "sysmapids": [             "10"         ]     },     "id": 1 } ```
he	#### צור מפת טריגר  צור מפה עם אלמנט טריגר, שמכיל שני טריגרים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "map.create",      "params": {          "name": "מפת טריגר",          "רוחב": 600,          "גובה": 600,          "אלמנטים": [              {                  "אלמנטים": [                      {"triggerid": "12345"},                      {"triggerid": "67890"}                  ],                  "elementtype": 2,                  "iconid_off": "2"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "sysmapids": [              "10"          ]      },      "מזהה": 1 } ```

en-us	#### Create a webhook script  Create a webhook script that sends HTTP request to external service.  Request:  ```json {     "jsonrpc": "2.0",     "method": "script.create",     "params": {         "name": "Webhook script",         "command": "try {\n var request = new HttpRequest(),\n response,\n data;\n\n request.addHeader('Content-Type: application/json');\n\n response = request.post('https://localhost/post', value);\n\n try {\n response = JSON.parse(response);\n }\n catch (error) {\n response = null;\n }\n\n if (request.getStatus() !== 200 || !('data' in response)) {\n throw 'Unexpected response.';\n }\n\n data = JSON.stringify(response.data);\n\n Zabbix.Log(3, '[Webhook Script] response data: ' + data);\n\n return data;\n}\ncatch (error) {\n Zabbix.Log(3, '[Webhook Script] script execution failed: ' + error);\n throw 'Execution failed: ' + error + '.';\n}",         "type": 5,         "timeout": "40s",         "parameters": [             {                 "name": "token",                 "value": "{$WEBHOOK.TOKEN}"             },             {                 "name": "host",                 "value": "{HOST.HOST}"             },             {                 "name": "v",                 "value": "2.2"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "scriptids": [             "3"         ]     },     "id": 1 } ```
he	#### צור סקריפט webhook  צור סקריפט webhook ששולח בקשת HTTP לשירות חיצוני.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "script.create",      "params": {          "name": "תסריט Webhook",          "command": "נסה {\n var request = new HttpRequest(),\n תגובה,\n נתונים;\n\n request.addHeader('Content-Type: application/json');\n\n תגובה = request.post('https://localhost/post', value);\n\n נסה את {\n response = JSON.parse(response);\n }\n תפס (שגיאה) {\n response = null; \n }\n\n if (request.getStatus() !== 200 || !('נתונים' בתגובה)) {\n זרוק 'תגובה בלתי צפויה.';\n }\n\n נתונים = JSON. stringify(response.data);\n\n Zabbix.Log(3, 'נתוני תגובה של [Webhook Script]: ' + data);\n\n החזר נתונים;\n}\nתפוס (שגיאה) {\n Zabbix. Log(3, 'ביצוע סקריפט [Webhook] נכשל: ' + error);\n throw 'הביצוע נכשל: ' + error + '.';\n}",          "סוג": 5,          "פסק זמן": "40s",          "פרמטרים": [              {                  "שם": "אסימון",                  "value": "{$WEBHOOK.TOKEN}"              },              {                  "name": "מארח",                  "value": "{HOST.HOST}"              },              {                  "name": "v",                  "value": "2.2"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "scriptids": [              "3"          ]      },      "מזהה": 1 } ```

en-us	#### Create HTTP agent item  Create POST request method item with JSON response preprocessing.  Request:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {         "url": "http://127.0.0.1/http.php",         "query_fields": [             {                 "mode": "json"             },             {                 "min": "10"             },             {                 "max": "100"             }         ],         "interfaceid": "1",         "type": 19,         "hostid": "10254",         "delay": "5s",         "key_": "json",         "name": "HTTP agent example JSON",         "value_type": 0,         "output_format": 1,         "preprocessing": [             {                 "type": 12,                 "params": "$.random",                 "error_handler": 0,                 "error_handler_params": ""             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 2 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "23865"         ]     },     "id": 3 } ```
he	#### צור פריט סוכן HTTP  צור פריט שיטת בקשת POST עם עיבוד מקדים של תגובת JSON.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {          "url": "http://127.0.0.1/http.php",          "query_fields": [              {                  "mode": "json"              },              {                  "min": "10"              },              {                  "max": "100"              }          ],          "interfaceid": "1",          "סוג": 19,          "hostid": "10254",          "delay": "5s",          "key_": "json",          "name": "דוגמה לסוכן HTTP JSON",          "ערך_סוג": 0,          "output_format": 1,          "עיבוד מקדים": [              {                  "סוג": 12,                  "params": "$.random",                  "error_handler": 0,                  "error_handler_params": ""              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 2 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "23865"          ]      },      "מזהה": 3 } ```

en-us	#### Create HTTP agent item prototype  Create item prototype with URL using user macro, query fields and custom headers.  Request:  ```json {     "jsonrpc": "2.0",     "method": "itemprototype.create",     "params": {         "type": "19",         "hostid": "10254",         "ruleid": "28256",         "interfaceid": "2",         "name": "api item prototype example",         "key_": "api_http_item",         "value_type": 3,         "url": "{$URL_PROTOTYPE}",         "query_fields": [             {                 "min": "10"             },             {                 "max": "100"             }         ],         "headers": {             "X-Source": "api"         },         "delay": "35"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "28305"         ]     },     "id": 1 } ```
he	#### צור אב טיפוס של פריט סוכן HTTP  צור אב טיפוס של פריט עם כתובת URL באמצעות מאקרו משתמש, שדות שאילתות והתאמה אישית כותרות.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "itemprototype.create",      "params": {          "type": "19",          "hostid": "10254",          "ruleid": "28256",          "interfaceid": "2",          "name": "דוגמה לאב-טיפוס של פריט API",          "key_": "api_http_item",          "ערך_סוג": 3,          "url": "{$URL_PROTOTYPE}",          "query_fields": [              {                  "min": "10"              },              {                  "max": "100"              }          ],          "headers": {              "X-Source": "API"          },          "עיכוב": "35"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "28305"          ]      },      "מזהה": 1 } ```

en-us	#### Create script item  Create a simple data collection using a script item.  Request:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {         "name": "Script example",         "key_": "custom.script.item",         "hostid": "12345",         "type": 21,         "value_type": 4,         "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",         "parameters": [             {                 "name": "host",                 "value": "{HOST.CONN}"             }         ],         "timeout": "6s",         "delay": "30s"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 2 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "23865"         ]     },     "id": 3 } ```
he	#### צור פריט סקריפט  צור איסוף נתונים פשוט באמצעות פריט סקריפט.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {          "name": "דוגמה לסקריפט",          "key_": "custom.script.item",          "hostid": "12345",          "סוג": 21,          "ערך_סוג": 4,          "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",          "פרמטרים": [              {                  "name": "מארח",                  "value": "{HOST.CONN}"              }          ],          "timeout": "6 שניות",          "delay": "30s"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 2 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "23865"          ]      },      "מזהה": 3 } ```

en-us	#### Create script item prototype  Create a simple data collection using a script item prototype.  Request:  ```json {     "jsonrpc": "2.0",     "method": "itemprototype.create",     "params": {         "name": "Script example",         "key_": "custom.script.itemprototype",         "hostid": "12345",         "type": 21,         "value_type": 4,         "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",         "parameters": [             {                 "name": "host",                 "value": "{HOST.CONN}"             }         ],         "timeout": "6s",         "delay": "30s"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 2 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "23865"         ]     },     "id": 3 } ```
he	#### צור אב טיפוס של פריט סקריפט  צור איסוף נתונים פשוט באמצעות אב טיפוס של פריט סקריפט.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "itemprototype.create",      "params": {          "name": "דוגמה לסקריפט",          "key_": "custom.script.itemprototype",          "hostid": "12345",          "סוג": 21,          "ערך_סוג": 4,          "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",          "פרמטרים": [              {                  "name": "מארח",                  "value": "{HOST.CONN}"              }          ],          "timeout": "6 שניות",          "delay": "30s"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 2 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "23865"          ]      },      "מזהה": 3 } ```

en-us	#### Create script LLD rule  Create a simple data collection using a script LLD rule.  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.create",     "params": {         "name": "Script example",         "key_": "custom.script.lldrule",         "hostid": "12345",         "type": 21,         "value_type": 4,         "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",         "parameters": [             {                 "name": "host",                 "value": "{HOST.CONN}"             }         ],         "timeout": "6s",         "delay": "30s"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 2 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "23865"         ]     },     "id": 3 } ```
he	#### צור כלל LLD של סקריפט  צור איסוף נתונים פשוט באמצעות כלל Script LLD.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.create",      "params": {          "name": "דוגמה לסקריפט",          "key_": "custom.script.lldrule",          "hostid": "12345",          "סוג": 21,          "ערך_סוג": 4,          "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",          "פרמטרים": [              {                  "name": "מארח",                  "value": "{HOST.CONN}"              }          ],          "פסק זמן": "6 שניות",          "delay": "30s"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 2 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "23865"          ]      },      "מזהה": 3 } ```

en-us	#### Creating a dashboard  Create a dashboard named "My dashboard" with one Problems widget with tags and using two types of sharing (user group and user) on a single dashboard page.  Request:  ```json {     "jsonrpc": "2.0",     "method": "dashboard.create",     "params": {         "name": "My dashboard",         "display_period": 30,         "auto_start": 1,         "pages": [             {                 "widgets": [                     {                         "type": "problems",                         "x": 0,                         "y": 0,                         "width": 12,                         "height": 5,                         "view_mode": 0,                         "fields": [                             {                                 "type": 1,                                 "name": "tags.tag.0",                                 "value": "service"                             },                             {                                 "type": 0,                                 "name": "tags.operator.0",                                 "value": 1                             },                             {                                 "type": 1,                                 "name": "tags.value.0",                                 "value": "zabbix_server"                             }                         ]                     }                 ]             }         ],         "userGroups": [             {                 "usrgrpid": "7",                 "permission": 2             }         ],         "users": [             {                 "userid": "4",                 "permission": 3             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "dashboardids": [             "2"         ]     },     "id": 1 } ```
he	#### יצירת לוח מחוונים  צור לוח מחוונים בשם "לוח המחוונים שלי" עם ווידג'ט בעיות אחד איתו תגיות ושימוש בשני סוגי שיתוף (קבוצת משתמשים ומשתמש) ביחיד דף לוח המחוונים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "dashboard.create",      "params": {          "name": "לוח המחוונים שלי",          "display_period": 30,          "התחל אוטומטי": 1,          "עמודים": [              {                  "יישומונים": [                      {                          "type": "בעיות",                          "x": 0,                          "y": 0,                          "רוחב": 12,                          "גובה": 5,                          "מצב_תצוגה": 0,                          "שדות": [                              {                                  "סוג 1,                                  "name": "tags.tag.0",                                  "value": "שירות"                              },                              {                                  "סוג": 0,                                  "name": "tags.operator.0",                                  "ערך": 1                              },                              {                                  "סוג 1,                                  "name": "tags.value.0",                                  "value": "zabbix_server"                              }                          ]                      }                  ]              }          ],          "קבוצות משתמש": [              {                  "usrgrpid": "7",                  "רשות": 2              }          ],          "משתמשים": [              {                  "userid": "4",                  "רשות": 3              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "dashboardids": [              "2"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a dashboard  It is possible to create a new dashboard in two ways:  -   Click on *Create dashboard*, when viewing all dashboards -   Select *Create new* from the action menu, when viewing a single     dashboard  You will be first asked to enter general dashboard parameters:  ![dashboard\_properties.png](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_properties.png)  |Parameter|Description| |--|--------| |*Owner*|Select system user that will be the dashboard owner.| |*Name*|Enter dashboard name.| |*Default page display period*|Select period for how long a dashboard page is displayed before rotating to the next page in a [slideshow](#creating_a_slideshow).| |*Start slideshow automatically*|Mark this checkbox to run a slideshow automatically one more than one dashboard page exists.|  When you click on *Apply*, an empty dashboard is opened:  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_add.png){width="600"}  To populate the dashboard, you can add widgets and pages.  Click on the *Save changes* button to save the dashboard. If you click on *Cancel*, the dashboard will not be created.
he	#### יצירת לוח מחוונים  אפשר ליצור לוח מחוונים חדש בשתי דרכים:  - לחץ על *צור לוח מחוונים*, בעת צפייה בכל לוחות המחוונים - בחר *צור חדש* מתפריט הפעולה, בעת צפייה בסינגל      לוּחַ מַחווָנִים  תחילה תתבקש להזין פרמטרים כלליים של לוח המחוונים:  ![dashboard\_properties.png](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_properties.png)  |פרמטר|תיאור| |--|--------| |*בעלים*|בחר משתמש מערכת שיהיה הבעלים של לוח המחוונים.| |*שם*|הזן את שם לוח המחוונים.| |*תקופת ברירת המחדל של תצוגת עמוד*|בחר תקופה למשך כמה זמן יוצג דף לוח מחוונים לפני סיבוב לעמוד הבא ב[מצגת_מצגת](#creating_a_slideshow).| |*התחל את מצגת שקופיות באופן אוטומטי*|סמן תיבת סימון זו כדי להפעיל מצגת באופן אוטומטי, קיים יותר מדף מחוונים אחד.|  כאשר אתה לוחץ על *החל*, נפתח לוח מחוונים ריק:  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_add.png){width="600"}  כדי לאכלס את לוח המחוונים, תוכל להוסיף ווידג'טים ודפים.  לחץ על כפתור *שמור שינויים* כדי לשמור את לוח המחוונים. אם תלחץ ב-*בטל*, לוח המחוונים לא ייווצר.

en-us	#### Creating a global macro  Create a global macro "{$SNMP\_COMMUNITY}" with value "public".  Request:  ```json {     "jsonrpc": "2.0",     "method": "usermacro.createglobal",     "params":  {         "macro": "{$SNMP_COMMUNITY}",         "value": "public"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "globalmacroids": [             "6"         ]     },     "id": 1 } ```
he	#### יצירת מאקרו גלובלי  צור מאקרו גלובלי "{$SNMP\_COMMUNITY}" עם הערך "ציבורי".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "usermacro.createglobal",      "params": {          "macro": "{$SNMP_COMMUNITY}",          "value": "ציבורי"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "גלובלמאקרואידים": [              "6"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a graph  Create a graph with two items.  Request:  ```json {     "jsonrpc": "2.0",     "method": "graph.create",     "params": {         "name": "MySQL bandwidth",         "width": 900,         "height": 200,         "gitems": [             {                 "itemid": "22828",                 "color": "00AA00"             },             {                 "itemid": "22829",                 "color": "3333FF"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "graphids": [             "652"         ]     },     "id": 1 } ```
he	#### יצירת גרף  צור גרף עם שני פריטים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "graph.create",      "params": {          "name": "רוחב פס MySQL",          "רוחב": 900,          "גובה": 200,          "gitems": [              {                  "itemid": "22828",                  "color": "00AA00"              },              {                  "itemid": "22829",                  "color": "3333FF"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "גרפים": [              "652"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a graph prototype  Create a graph prototype with two items.  Request:  ```json {     "jsonrpc": "2.0",     "method": "graphprototype.create",     "params": {         "name": "Disk space usage {#FSNAME}",         "width": 900,         "height": 200,         "gitems": [             {                 "itemid": "22828",                 "color": "00AA00"             },             {                 "itemid": "22829",                 "color": "3333FF"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "graphids": [             "652"         ]     },     "id": 1 } ```
he	#### יצירת אב טיפוס של גרף  צור אב טיפוס גרף עם שני פריטים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "graphprototype.create",      "params": {          "name": "שימוש בשטח דיסק {#FSNAME}",          "רוחב": 900,          "גובה": 200,          "gitems": [              {                  "itemid": "22828",                  "color": "00AA00"              },              {                  "itemid": "22829",                  "color": "3333FF"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "גרפים": [              "652"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host  Create a host called "Linux server" with an IP interface and tags, add it to a group, link a template to it and set the MAC addresses in the host inventory.  Request:  ```json {     "jsonrpc": "2.0",     "method": "host.create",     "params": {         "host": "Linux server",         "interfaces": [             {                 "type": 1,                 "main": 1,                 "useip": 1,                 "ip": "192.168.3.1",                 "dns": "",                 "port": "10050"             }         ],         "groups": [             {                 "groupid": "50"             }         ],         "tags": [             {                 "tag": "Host name",                 "value": "Linux server"             }         ],         "templates": [             {                 "templateid": "20045"             }         ],         "macros": [             {                 "macro": "{$USER_ID}",                 "value": "123321"             },             {                 "macro": "{$USER_LOCATION}",                 "value": "0:0:0",                 "description": "latitude, longitude and altitude coordinates"             }         ],         "inventory_mode": 0,         "inventory": {             "macaddress_a": "01234",             "macaddress_b": "56768"         }     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "hostids": [             "107819"         ]     },     "id": 1 } ```
he	#### יצירת מארח  צור מארח בשם "שרת לינוקס" עם ממשק IP ותגים, הוסף זה לקבוצה, קשר אליו תבנית והגדר את כתובות ה-MAC ב- מלאי המארח.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "host.create",      "params": {          "host": "שרת לינוקס",          "ממשקים": [              {                  "סוג 1,                  "ראשי": 1,                  "useip": 1,                  "ip": "192.168.3.1",                  "dns": "",                  "port": "10050"              }          ],          "קבוצות": [              {                  "groupid": "50"              }          ],          "תגים": [              {                  "tag": "שם מארח",                  "value": "שרת לינוקס"              }          ],          "תבניות": [              {                  "templateid": "20045"              }          ],          "מאקרו": [              {                  "macro": "{$USER_ID}",                  "value": "123321"              },              {                  "macro": "{$USER_LOCATION}",                  "value": "0:0:0",                  "description": "קואורדינטות של קווי רוחב, קו אורך וגובה"              }          ],          "מצב_מלאי": 0,          "מלאי": {              "macaddress_a": "01234",              "macaddress_b": "56768"          }      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "hostids": [              "107819"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host group  Create a host group called "Linux servers".  Request:  ```json {     "jsonrpc": "2.0",     "method": "hostgroup.create",     "params": {         "name": "Linux servers"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "groupids": [             "107819"         ]     },     "id": 1 } ```
he	#### יצירת קבוצה מארחת  צור קבוצה מארחת בשם "שרתי לינוקס".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "hostgroup.create",      "params": {          "name": "שרתי לינוקס"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "קבוצות": [              "107819"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host group  ::: noteimportant Only Super Admin users can create host groups. :::  To create a host group in Zabbix frontend, do the following:  -   Go to: *Configuration → Host groups* -   Click on *Create Group* in the upper right corner of the screen -   Enter parameters of the group in the form  ![](../../../../assets/en/manual/config/host_group.png)  All mandatory input fields are marked with a red asterisk.  |Parameter|Description| |---------|-----------| |*Group name*|Enter a unique host group name.<br>To create a nested host group, use the '/' forward slash separator, for example `Europe/Latvia/Riga/Zabbix servers`. You can create this group even if none of the three parent host groups (`Europe/Latvia/Riga`) exist. In this case creating these parent host groups is up to the user; they will not be created automatically.<br>Leading and trailing slashes, several slashes in a row are not allowed. Escaping of '/' is not supported.<br>Nested representation of host groups is supported since Zabbix 3.2.0.| |*Apply permissions and tag filters to all subgroups*|Checkbox is available to Super Admin users only and only when editing an existing host group.<br>Mark this checkbox and click on *Update* to apply the same level of permissions/tag filters to all nested host groups. For user groups that may have had differing [permissions](/manual/config/users_and_usergroups/usergroup#configuration) assigned to nested host groups, the permission level of the parent host group will be enforced on the nested groups.<br>This is a one-time option that is not saved in the database.<br>This option is supported since Zabbix 3.4.0.|  **Permissions to nested host groups**  -   When creating a child host group to an existing parent host group,     [user group](/manual/config/users_and_usergroups/usergroup)     permissions to the child are inherited from the parent (for example,     when creating `Riga/Zabbix servers` if `Riga` already exists) -   When creating a parent host group to an existing child host group,     no permissions to the parent are set (for example, when creating     `Riga` if `Riga/Zabbix servers` already exists)
he	#### יצירת קבוצה מארחת  ::: שימו לב חשוב רק משתמשי Super Admin יכולים ליצור קבוצות מארחות. :::  כדי ליצור קבוצה מארחת בחזית Zabbix, בצע את הפעולות הבאות:  - עבור אל: *תצורה ← מארח קבוצות* - לחץ על *צור קבוצה* בפינה השמאלית העליונה של המסך - הזינו פרמטרים של הקבוצה בטופס  ![](../../../../assets/en/manual/config/host_group.png)  כל שדות הקלט החובה מסומנים בכוכבית אדומה.  |פרמטר|תיאור| |--------|--------| |*שם קבוצה*|הזן שם ייחודי של קבוצת מארח.<br>כדי ליצור קבוצת מארחים מקוננת, השתמש במפריד הלוכסן קדימה '/', לדוגמה 'אירופה/לטביה/ריגה/שרתי Zabbix'. אתה יכול ליצור קבוצה זו גם אם אף אחת משלוש קבוצות האב המארחות (`אירופה/לטביה/ריגה`) לא קיימת. במקרה זה יצירת קבוצות מארח אב אלה תלויה במשתמש; הם לא ייווצרו באופן אוטומטי.<br>אלכסונים מובילים ונגררים, מספר חתכים ברציפות אינם מותרים. בריחה של '/' אינה נתמכת.<br>ייצוג מקונן של קבוצות מארחות נתמך מאז Zabbix 3.2.0.| |*החל הרשאות ומסנני תגים על כל תת-הקבוצות*|תיבת הסימון זמינה למשתמשי Super Admin בלבד ורק בעת עריכת קבוצה מארחת קיימת.<br>סמן תיבת סימון זו ולחץ על *עדכן* כדי להחיל את אותה רמה של הרשאות/תג מסננים לכל קבוצות המארחים המקוננות. עבור קבוצות משתמשים שאולי הוקצו להן [הרשאות](/manual/config/users_and_usergroups/usergroup#configuration) לקבוצות מארחים מקוננות, רמת ההרשאה של קבוצת המארחים האב תיאכף על הקבוצות המקוננות.<br>זהו אפשרות חד פעמית שאינה נשמרת במסד הנתונים.<br>אפשרות זו נתמכת מאז Zabbix 3.4.0.|  **הרשאות לקבוצות מארחות מקוננות**  - בעת יצירת קבוצת מארח ילד לקבוצת מארחת אב קיימת,      [קבוצת משתמשים](/manual/config/users_and_usergroups/usergroup)      ההרשאות לילד עוברות בירושה מההורה (לדוגמה,      בעת יצירת שרתי ריגה/זאביקס, אם כבר קיים 'ריגה') - בעת יצירת קבוצת אב מארחת לקבוצת מארחת ילדה קיימת,      לא מוגדרות הרשאות להורה (לדוגמה, בעת יצירה      `Riga` אם `Riga/Zabix servers` כבר קיימים)

en-us	#### Creating a host inventory item  Create a Zabbix agent item to populate the host's "OS" inventory field.  Request:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {         "name": "uname",         "key_": "system.uname",         "hostid": "30021",         "type": 0,         "interfaceid": "30007",         "value_type": 1,         "delay": "10s",         "inventory_link": 5     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "24759"         ]     },     "id": 1 } ```
he	#### יצירת פריט מלאי מארח  צור פריט סוכן של Zabbix כדי לאכלס את שדה המלאי "OS" של המארח.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {          "name": "uname",          "key_": "system.uname",          "hostid": "30021",          "סוג": 0,          "interfaceid": "30007",          "סוג_ערך": 1,          "delay": "10s",          "קישור_מלאי": 5      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "24759"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host macro  Create a host macro "{$SNMP\_COMMUNITY}" with the value "public" on host "10198".  Request:  ```json {     "jsonrpc": "2.0",     "method": "usermacro.create",     "params": {         "hostid": "10198",         "macro": "{$SNMP_COMMUNITY}",         "value": "public"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "hostmacroids": [             "11"         ]     },     "id": 1 } ```
he	#### יצירת מאקרו מארח  צור מאקרו מארח "{$SNMP\_COMMUNITY}" עם הערך "ציבורי" על המארח "10198".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "usermacro.create",      "params": {          "hostid": "10198",          "macro": "{$SNMP_COMMUNITY}",          "value": "ציבורי"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "hostmacroids": [              "11"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host prototype  Create a host prototype "{\#VM.NAME}" on LLD rule "23542" with a group prototype "{\#HV.NAME}", tag pair "Datacenter": "{\#DATACENTER.NAME}" and custom SNMPv2 interface 127.0.0.1:161 with community {$SNMP\_COMMUNITY}. Link it to host group "2".  Request:  ```json {     "jsonrpc": "2.0",     "method": "hostprototype.create",     "params": {         "host": "{#VM.NAME}",         "ruleid": "23542",         "custom_interfaces": "1",         "groupLinks": [             {                 "groupid": "2"             }         ],         "groupPrototypes": [             {                 "name": "{#HV.NAME}"             }         ],         "tags": [             {                 "tag": "Datacenter",                 "value": "{#DATACENTER.NAME}"             }         ],         "interfaces": [             {                 "main": "1",                 "type": "2",                 "useip": "1",                 "ip": "127.0.0.1",                 "dns": "",                 "port": "161",                 "details": {                     "version": "2",                     "bulk": "1",                     "community": "{$SNMP_COMMUNITY}"                 }             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "hostids": [             "10103"         ]     },     "id": 1 } ```
he	#### יצירת אב טיפוס מארח  צור אב טיפוס מארח "{\#VM.NAME}" על כלל LLD "23542" עם קבוצה אב טיפוס "{\#HV.NAME}", זוג תגים "Datacenter": "{\#DATACENTER.NAME}" וממשק SNMPv2 מותאם אישית 127.0.0.1:161 עם קהילה {$SNMP\_COMMUNITY}. קשר אותו לקבוצה המארח "2".  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "hostprototype.create",      "params": {          "host": "{#VM.NAME}",          "ruleid": "23542",          "custom_interfaces": "1",          "קבוצת קישורים": [              {                  "groupid": "2"              }          ],          "groupPrototypes": [              {                  "name": "{#HV.NAME}"              }          ],          "תגים": [              {                  "tag": "מרכז נתונים",                  "value": "{#DATACENTER.NAME}"              }          ],          "ממשקים": [              {                  "main": "1",                  "type": "2",                  "useip": "1",                  "ip": "127.0.0.1",                  "dns": "",                  "port": "161",                  "פרטים": {                      "גרסה 2",                      "bulk": "1",                      "קהילה": "{$SNMP_COMMUNITY}"                  }              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "hostids": [              "10103"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a host with SNMP interface  Create a host called "SNMP host" with an SNMPv3 interface with details.  Request:  ```json {     "jsonrpc": "2.0",     "method": "host.create",     "params": {         "host": "SNMP host",         "interfaces": [             {                 "type": 2,                 "main": 1,                 "useip": 1,                 "ip": "127.0.0.1",                 "dns": "",                 "port": "161",                 "details": {                     "version": 3,                     "bulk": 0,                     "securityname": "mysecurityname",                     "contextname": "",                     "securitylevel": 1                 }             }         ],         "groups": [             {                 "groupid": "4"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "hostids": [             "10658"         ]     },     "id": 1 } ```
he	#### יצירת מארח עם ממשק SNMP  צור מארח בשם "מארח SNMP" עם ממשק SNMPv3 עם פרטים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "host.create",      "params": {          "host": "מארח SNMP",          "ממשקים": [              {                  "סוג": 2,                  "ראשי": 1,                  "useip": 1,                  "ip": "127.0.0.1",                  "dns": "",                  "port": "161",                  "פרטים": {                      "גרסה": 3,                      "כמות גדולה": 0,                      "securityname": "mysecurityname",                      "contextname": "",                      "רמת אבטחה": 1                  }              }          ],          "קבוצות": [              {                  "groupid": "4"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "hostids": [              "10658"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a LLD rule with macro paths  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.create",     "params": {         "name": "LLD rule with LLD macro paths",         "key_": "lld",         "hostid": "10116",         "type": 0,         "interfaceid": "13",         "delay": "30s",         "lld_macro_paths": [             {                 "lld_macro": "{#MACRO1}",                 "path": "$.path.1"             },             {                 "lld_macro": "{#MACRO2}",                 "path": "$.path.2"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "27665"         ]     },     "id": 1 } ```
he	#### יצירת כלל LLD עם נתיבי מאקרו  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.create",      "params": {          "name": "כלל LLD עם נתיבי מאקרו LLD",          "key_": "lld",          "hostid": "10116",          "סוג": 0,          "interfaceid": "13",          "delay": "30s",          "lld_macro_paths": [              {                  "lld_macro": "{#MACRO1}",                  "path": "$.path.1"              },              {                  "lld_macro": "{#MACRO2}",                  "path": "$.path.2"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "27665"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a LLD rule with overrides  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.create",     "params": {         "name": "Discover database host",         "key_": "lld.with.overrides",         "hostid": "10001",         "type": 0,         "value_type": 3,         "delay": "60s",         "interfaceid": "1155",         "overrides": [             {                 "name": "Discover MySQL host",                 "step": "1",                 "stop": "1",                 "filter": {                     "evaltype": "2",                     "conditions": [                         {                             "macro": "{#UNIT.NAME}",                             "operator": "8",                             "value": "^mysqld\\.service$"                         },                         {                             "macro": "{#UNIT.NAME}",                             "operator": "8",                             "value": "^mariadb\\.service$"                         }                     ]                 },                 "operations": [                     {                         "operationobject": "3",                         "operator": "2",                         "value": "Database host",                         "opstatus": {                             "status": "0"                         },                         "optemplate": [                             {                                 "templateid": "10170"                             }                         ],                         "optag": [                             {                                 "tag": "Database",                                 "value": "MySQL"                             }                         ]                     }                 ]             },             {                 "name": "Discover PostgreSQL host",                 "step": "2",                 "stop": "1",                 "filter": {                     "evaltype": "0",                     "conditions": [                         {                             "macro": "{#UNIT.NAME}",                             "operator": "8",                             "value": "^postgresql\\.service$"                         }                     ]                 },                 "operations": [                     {                         "operationobject": "3",                         "operator": "2",                         "value": "Database host",                         "opstatus": {                             "status": "0"                         },                         "optemplate": [                             {                                 "templateid": "10263"                             }                         ],                         "optag": [                             {                                 "tag": "Database",                                 "value": "PostgreSQL"                             }                         ]                     }                 ]             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "30980"         ]     },     "id": 1 } ```
he	#### יצירת כלל LLD עם עקיפות  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.create",      "params": {          "name": "גלה מארח מסד הנתונים",          "key_": "lld.with.overrides",          "hostid": "10001",          "סוג": 0,          "ערך_סוג": 3,          "delay": "שנות ה-60",          "interfaceid": "1155",          "עוקף": [              {                  "name": "גלה מארח MySQL",                  "שלב 1",                  "stop": "1",                  "מסנן": {                      "evaltype": "2",                      "תנאים": [                          {                              "macro": "{#UNIT.NAME}",                              "מפעיל": "8",                              "value": "^mysqld\\.service$"                          },                          {                              "macro": "{#UNIT.NAME}",                              "מפעיל": "8",                              "value": "^mariadb\\.service$"                          }                      ]                  },                  "פעולות": [                      {                          "operationobject": "3",                          "מפעיל": "2",                          "value": "מארח מסד נתונים",                          "opstatus": {                              "סטטוס": "0"                          },                          "optemplate": [                              {                                  "templateid": "10170"                              }                          ],                          "optag": [                              {                                  "tag": "מסד נתונים",                                  "value": "MySQL"                              }                          ]                      }                  ]              },              {                  "name": "גלה מארח PostgreSQL",                  "שלב 2",                  "stop": "1",                  "מסנן": {                      "evaltype": "0",                      "תנאים": [                          {                              "macro": "{#UNIT.NAME}",                              "מפעיל": "8",                              "value": "^postgresql\\.service$"                          }                      ]                  },                  "פעולות": [                      {                          "operationobject": "3",                          "מפעיל": "2",                          "value": "מארח מסד נתונים",                          "opstatus": {                              "סטטוס": "0"                          },                          "optemplate": [                              {                                  "templateid": "10263"                              }                          ],                          "optag": [                              {                                  "tag": "מסד נתונים",                                  "value": "PostgreSQL"                              }                          ]                      }                  ]              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "30980"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a LLD rule with preprocessing  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.create",     "params": {         "name": "Discovery rule with preprocessing",         "key_": "lld.with.preprocessing",         "hostid": "10001",         "ruleid": "27665",         "type": 0,         "value_type": 3,         "delay": "60s",         "interfaceid": "1155",         "preprocessing": [             {                 "type": 20,                 "params": "20",                 "error_handler": 0,                 "error_handler_params": ""             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "44211"         ]     },     "id": 1 } ```
he	#### יצירת כלל LLD עם עיבוד מקדים  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.create",      "params": {          "name": "כלל גילוי עם עיבוד מקדים",          "key_": "lld.with.preprocessing",          "hostid": "10001",          "ruleid": "27665",          "סוג": 0,          "ערך_סוג": 3,          "delay": "שנות ה-60",          "interfaceid": "1155",          "עיבוד מוקדם": [              {                  "סוג": 20,                  "params": "20",                  "error_handler": 0,                  "error_handler_params": ""              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "44211"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a maintenance  Create a maintenance with data collection for host group with ID "2" and with problem tags **service:mysqld** and **error**. It must be active from 22.01.2013 till 22.01.2014, come in effect each Sunday at 18:00 and last for one hour.  Request:  ```json {     "jsonrpc": "2.0",     "method": "maintenance.create",     "params": {         "name": "Sunday maintenance",         "active_since": 1358844540,         "active_till": 1390466940,         "tags_evaltype": 0,         "groups": [             {"groupid": "2"}         ],         "timeperiods": [             {                 "period": 3600,                 "timeperiod_type": 3,                 "start_time": 64800,                 "every": 1,                 "dayofweek": 64             }         ],         "tags": [             {                 "tag": "service",                 "operator": "0",                 "value": "mysqld"             },             {                 "tag": "error",                 "operator": "2",                 "value": ""             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "maintenanceids": [             "3"         ]     },     "id": 1 } ```
he	#### יצירת תחזוקה  צור תחזוקה עם איסוף נתונים לקבוצה מארחת עם מזהה "2" ועם תגי בעיה **service:mysqld** ו**שגיאה**. זה חייב להיות פעיל מ 22.01.2013 עד 22.01.2014, ייכנסו לתוקף בכל יום ראשון בשעה 18:00 ועד אחרון לשעה אחת.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "maintenance.create",      "params": {          "name": "תחזוקה ביום ראשון",          "active_since": 1358844540,          "פעיל_עד": 1390466940,          "tags_evaltype": 0,          "קבוצות": [              {"groupid": "2"}          ],          "תקופות זמן": [              {                  "תקופה": 3600,                  "timeperiod_type": 3,                  "זמן_התחלה": 64800,                  "כל": 1,                  "יום בשבוע": 64              }          ],          "תגים": [              {                  "tag": "שירות",                  "מפעיל": "0",                  "value": "mysqld"              },              {                  "tag": "שגיאה",                  "מפעיל": "2",                  "ערך": ""              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "תחזוקה": [              "3"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a map  To create a map, do the following:  -   Go to *Monitoring → Maps* -   Go to the view with all maps -   Click on *Create map*  You can also use the *Clone* and *Full clone* buttons in the configuration form of an existing map to create a new map. Clicking on *Clone* will retain general layout attributes of the original map, but no elements. *Full clone* will retain both the general layout attributes and all elements of the original map.  The **Map** tab contains general map attributes:  ![](../../../../../assets/en/manual/config/visualization/map_config.png)  All mandatory input fields are marked with a red asterisk.  General map attributes:  |Parameter|Description| |--|--------| |*Owner*|Name of map owner.| |*Name*|Unique map name.| |*Width*|Map width in pixels.| |*Height*|Map height in pixels.| |*Background image*|Use background image:<br>**No image** - no background image (white background)<br>**Image** - selected image to be used as a background image. No scaling is performed. You may use a geographical map or any other image to enhance your map.| |*Automatic icon mapping*|You can set to use an automatic icon mapping, configured in *Administration → General → Icon mapping*. Icon mapping allows mapping certain icons against certain host inventory fields.| |*Icon highlighting*|If you check this box, map elements will receive highlighting.<br>Elements with an active trigger will receive a round background, in the same color as the highest severity trigger. Moreover, a thick green line will be displayed around the circle, if all problems are acknowledged.<br>Elements with "disabled" or "in maintenance" status will get a square background, gray and orange respectively.<br>See also: [Viewing maps](/manual/web_interface/frontend_sections/monitoring/maps#viewing_maps)| |*Mark elements on trigger status change*|A recent change of trigger status (recent problem or resolution) will be highlighted with markers (inward-pointing red triangles) on the three sides of the element icon that are free of the label. Markers are displayed for 30 minutes.| |*Display problems*|Select how problems are displayed with a map element:<br>**Expand single problem** - if there is only one problem, the problem name is displayed. Otherwise, the total number of problems is displayed.<br>**Number of problems** - the total number of problems is displayed<br>**Number of problems and expand most critical one** - the name of the most critical problem and the total number of problems is displayed.<br>'Most critical' is determined based on problem severity and, if equal, problem event ID (higher ID or later problem displayed first). For a *trigger map element* it is based on problem severity and if equal, trigger position in the trigger list. In case of multiple problems of the same trigger, the most recent one will be displayed.| |*Advanced labels*|If you check this box you will be able to define separate label types for separate element types.| |*Map element label type*|Label type used for map elements:<br>**Label** - map element label<br>**IP address** - IP address<br>**Element name** - element name (for example, host name)<br>**Status only** - status only (OK or PROBLEM)<br>**Nothing** - no labels are displayed| |*Map element label location*|Label location in relation to the map element:<br>**Bottom** - beneath the map element<br>**Left** - to the left<br>**Right** - to the right<br>**Top** - above the map element| |*Problem display*|Display problem count as:<br>**All** - full problem count will be displayed<br>**Separated** - unacknowledged problem count will be displayed separated as a number of the total problem count<br>**Unacknowledged only** - only the unacknowledged problem count will be displayed| |*Minimum trigger severity*|Problems below the selected minimum severity level will not be displayed on the map.<br>For example, with *Warning* selected, changes with *Information* and *Not classified* level triggers will not be reflected in the map.<br>This parameter is supported starting with Zabbix 2.2.| |*Show suppressed problems*|Mark the checkbox to display problems that would otherwise be suppressed (not shown) because of host maintenance.| |*URLs*|URLs for each element type can be defined (with a label). These will be displayed as links when a user clicks on the element in the map viewing mode.<br>Macros can be used in map URL names and values. For a full list, see [supported macros](/manual/appendix/macros/supported_by_location) and search for 'map URL names and values'.|
he	)

en-us	#### Creating an e-mail media type  Create a new e-mail media type with a custom SMTP port and message templates.  Request:  ```json {     "jsonrpc": "2.0",     "method": "mediatype.create",     "params": {         "type": "0",         "name": "E-mail",         "smtp_server": "mail.example.com",         "smtp_helo": "example.com",         "smtp_email": "zabbix@example.com",         "smtp_port": "587",         "content_type": "1",         "message_templates": [             {                 "eventsource": "0",                 "recovery": "0",                 "subject": "Problem: {EVENT.NAME}",                 "message": "Problem \"{EVENT.NAME}\" on host \"{HOST.NAME}\" started at {EVENT.TIME}."             },             {                 "eventsource": "0",                 "recovery": "1",                 "subject": "Resolved in {EVENT.DURATION}: {EVENT.NAME}",                 "message": "Problem \"{EVENT.NAME}\" on host \"{HOST.NAME}\" has been resolved at {EVENT.RECOVERY.TIME} on {EVENT.RECOVERY.DATE}."             },             {                 "eventsource": "0",                 "recovery": "2",                 "subject": "Updated problem in {EVENT.AGE}: {EVENT.NAME}",                 "message": "{USER.FULLNAME} {EVENT.UPDATE.ACTION} problem \"{EVENT.NAME}\" on host \"{HOST.NAME}\" at {EVENT.UPDATE.DATE} {EVENT.UPDATE.TIME}."             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "mediatypeids": [             "7"         ]     },     "id": 1 } ```
he	### החזר ערכים  `(אובייקט)` מחזירה אובייקט המכיל את המזהים של המדיה שנוצרה סוגים תחת המאפיין 'mediatypeids'. סדר התעודות המוחזרות תואם את הסדר של סוגי המדיה שעברו.

en-us	#### Creating a new global regular expression.  Request:  ```json {     "jsonrpc": "2.0",     "method": "regexp.create",     "params": {       "name": "Storage devices for SNMP discovery",       "test_string": "/boot",       "expressions": [         {           "expression": "^(Physical memory|Virtual memory|Memory buffers|Cached memory|Swap space)$",           "expression_type": "4",           "case_sensitive": "1"         }       ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "regexpids": [             "16"         ]     },     "id": 1 } ```
he	#### יצירת ביטוי רגולרי גלובלי חדש.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "regexp.create",      "params": {        "name": "התקני אחסון לגילוי SNMP",        "test_string": "/boot",        "ביטויים": [          {            "expression": "^(זיכרון פיזי|זיכרון וירטואלי|מאגרי זיכרון|זיכרון במטמון|החלפת שטח)$",            "expression_type": "4",            "case_sensitive": "1"          }        ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "regexpids": [              "16"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a new item  Let's create a new [item](/manual/api/reference/item/object) on "Zabbix server" using the data we've obtained from the previous `host.get` request. This can be done by using the [item.create](/manual/api/reference/item/create) method:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {         "name": "Free disk space on /home/joe/",         "key_": "vfs.fs.size[/home/joe/,free]",         "hostid": "10084",         "type": 0,         "value_type": 3,         "interfaceid": "1",         "delay": 30     },     "auth": "0424bd59b807674191e7d77572075f33",     "id": 3 } ```  A successful response will contain the ID of the newly created item, which can be used to reference the item in the following requests:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "24759"         ]     },     "id": 3 } ```  ::: notetip The `item.create` method as well as other create methods can also accept arrays of objects and create multiple items with one API call. :::
he	#### יצירת פריט חדש  בואו ניצור [פריט](/manual/api/reference/item/object) חדש ב-Zabbix server" באמצעות הנתונים שהשגנו מה-host.get הקודם בַּקָשָׁה. ניתן לעשות זאת על ידי שימוש ב- שיטת [item.create](/manual/api/reference/item/create):  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {          "name": "שטח דיסק פנוי ב-/home/joe/",          "key_": "vfs.fs.size[/home/joe/,free]",          "hostid": "10084",          "סוג": 0,          "ערך_סוג": 3,          "interfaceid": "1",          "עיכוב": 30      },      "auth": "0424bd59b807674191e7d77572075f33",      "מזהה": 3 } ```  תגובה מוצלחת תכיל את המזהה של הפריט החדש שנוצר, שבו ניתן להשתמש כדי להתייחס לפריט בבקשות הבאות:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "24759"          ]      },      "מזהה": 3 } ```  ::: הערה שיטת 'item.create' כמו גם שיטות יצירה אחרות יכול גם לקבל מערכים של אובייקטים וליצור מספר פריטים עם API אחד שִׂיחָה. :::

en-us	#### Creating an item prototype with preprocessing  Create an item using change per second and a custom multiplier as a second step.  Request:  ```json {     "jsonrpc": "2.0",     "method": "itemprototype.create",     "params": {         "name": "Incoming network traffic on {#IFNAME}",         "key_": "net.if.in[{#IFNAME}]",         "hostid": "10001",         "ruleid": "27665",         "type": 0,         "value_type": 3,         "delay": "60s",         "units": "bps",         "interfaceid": "1155",         "preprocessing": [             {                 "type": 10,                 "params": "",                 "error_handler": 0,                 "error_handler_params": ""             },             {                 "type": 1,                 "params": "8",                 "error_handler": 2,                 "error_handler_params": "10"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "44211"         ]     },     "id": 1 } ```
he	#### יצירת אב טיפוס של פריט עם עיבוד מקדים  צור פריט באמצעות שינוי לשנייה ומכפיל מותאם אישית בתור א צעד שני.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "itemprototype.create",      "params": {          "name": "תעבורת רשת נכנסת ב-{#IFNAME}",          "key_": "net.if.in[{#IFNAME}]",          "hostid": "10001",          "ruleid": "27665",          "סוג": 0,          "ערך_סוג": 3,          "delay": "שנות ה-60",          "יחידות": "bps",          "interfaceid": "1155",          "עיבוד מקדים": [              {                  "סוג": 10,                  "params": "",                  "error_handler": 0,                  "error_handler_params": ""              },              {                  "סוג 1,                  "params": "8",                  "error_handler": 2,                  "error_handler_params": "10"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "44211"          ]      },      "מזהה": 1 } ```

en-us	#### Creating an item with preprocessing  Create an item using custom multiplier.  Request:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {         "name": "Device uptime",         "key_": "sysUpTime",         "hostid": "11312",         "type": 4,         "snmp_oid": "SNMPv2-MIB::sysUpTime.0",         "value_type": 1,         "delay": "60s",         "units": "uptime",         "interfaceid": "1156",         "preprocessing": [             {                 "type": 1,                 "params": "0.01",                 "error_handler": 1,                 "error_handler_params": ""             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "44210"         ]     },     "id": 1 } ```
he	#### יצירת פריט עם עיבוד מקדים  צור פריט באמצעות מכפיל מותאם אישית.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {          "name": "זמן פעילות של המכשיר",          "key_": "sysUpTime",          "hostid": "11312",          "סוג": 4,          "snmp_oid": "SNMPv2-MIB::sysUpTime.0",          "סוג_ערך": 1,          "delay": "שנות ה-60",          "יחידות": "זמן פעולה",          "interfaceid": "1156",          "עיבוד מקדים": [              {                  "סוג 1,                  "params": "0.01",                  "error_handler": 1,                  "error_handler_params": ""              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "44210"          ]      },      "מזהה": 1 } ```

en-us	#### Creating an LLD rule  Create a Zabbix agent LLD rule to discover mounted file systems. Discovered items will be updated every 30 seconds.  Request:  ```json {     "jsonrpc": "2.0",     "method": "discoveryrule.create",     "params": {         "name": "Mounted filesystem discovery",         "key_": "vfs.fs.discovery",         "hostid": "10197",         "type": 0,         "interfaceid": "112",         "delay": "30s"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "27665"         ]     },     "id": 1 } ```
he	#### יצירת כלל LLD  צור כלל LLD של סוכן Zabbix כדי לגלות מערכות קבצים רכובות. פריטים שהתגלו יעודכנו כל 30 שניות.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "discoveryrule.create",      "params": {          "name": "גילוי מערכת קבצים מותקן",          "key_": "vfs.fs.discovery",          "hostid": "10197",          "סוג": 0,          "interfaceid": "112",          "delay": "30s"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "27665"          ]      },      "מזהה": 1 } ```

en-us	#### Creating an SLA  Instruct to create an SLA entry for: * tracking uptime for SQL-engine related services; * custom schedule of all weekdays excluding last hour on Saturday; * an effective date of the last day of the year 2022; * with 1 hour and 15 minutes long planned downtime starting at midnight on the 4th of July; * SLA weekly report calculation will be on; * the minimum acceptable SLO will be 99.9995%.
he	#### יצירת SLA  הוראה ליצור ערך SLA עבור: * מעקב אחר זמן פעולה עבור שירותים הקשורים למנועי SQL; * לוח זמנים מותאם אישית של כל ימי השבוע למעט השעה האחרונה בשבת; * תאריך תוקף של היום האחרון של שנת 2022; * עם זמן השבתה מתוכנן של שעה ו-15 דקות החל מחצות ב-4 ביולי; * חישוב דוח שבועי של SLA יופעל; * SLO המינימלי המקובל יהיה 99.9995%.

en-us	#### Creating a role  Create a role with type "User" and denied access to two UI elements.  Request:  ```json {     "jsonrpc": "2.0",     "method": "role.create",     "params": {         "name": "Operator",         "type": "1",         "rules": {             "ui": [                 {                     "name": "monitoring.hosts",                     "status": "0"                 },                 {                     "name": "monitoring.maps",                     "status": "0"                 }             ]         }     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "roleids": [             "5"         ]     },     "id": 1 } ```
he	#### יצירת תפקיד  צור תפקיד עם סוג "User" ודחיית גישה לשני רכיבי ממשק משתמש.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "role.create",      "params": {          "name": "מפעיל",          "סוג 1",          "כללים": {              "ui": [                  {                      "name": "monitoring.hosts",                      "סטטוס": "0"                  },                  {                      "name": "monitoring.maps",                      "סטטוס": "0"                  }              ]          }      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "roleids": [              "5"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a scheduled report  Create a weekly report that will be prepared for the previous week every Monday-Friday at 12:00 from 2021-04-01 to 2021-08-31.  Request:  ```json {     "jsonrpc": "2.0",     "method": "report.create",     "params": {         "userid": "1",         "name": "Weekly report",         "dashboardid": "1",         "period": "1",         "cycle": "1",         "start_time": "43200",         "weekdays": "31",         "active_since": "2021-04-01",         "active_till": "2021-08-31",         "subject": "Weekly report",         "message": "Report accompanying text",         "status": "1",         "description": "Report description",         "users": [             {                 "userid": "1",                 "access_userid": "1",                 "exclude": "0"             },             {                 "userid": "2",                 "access_userid": "0",                 "exclude": "1"             }         ],         "user_groups": [             {                 "usrgrpid": "7",                 "access_userid": "0"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "reportids": [             "1"         ]     },     "id": 1 } ```
he	#### יצירת דוח מתוזמן  צור דוח שבועי שיוכן עבור השבוע הקודם מדי פעם שני-שישי בשעה 12:00 מ-2021-04-01 עד 2021-08-31.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "report.create",      "params": {          "userid": "1",          "name": "דוח שבועי",          "dashboardid": "1",          "תקופה 1",          "מחזור": "1",          "start_time": "43200",          "ימי חול": "31",          "active_since": "2021-04-01",          "active_till": "2021-08-31",          "subject": "דוח שבועי",          "message": "דווח על טקסט נלווה",          "status": "1",          "description": "תיאור הדוח",          "משתמשים": [              {                  "userid": "1",                  "access_userid": "1",                  "exclude": "0"              },              {                  "userid": "2",                  "access_userid": "0",                  "exclude": "1"              }          ],          "קבוצות משתמש": [              {                  "usrgrpid": "7",                  "access_userid": "0"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "דיווחים": [              "1"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a script media type  Create a new script media type with a custom value for the number of attempts and the interval between them.  Request:  ```json {     "jsonrpc": "2.0",     "method": "mediatype.create",     "params": {         "type": "1",         "name": "Push notifications",         "exec_path": "push-notification.sh",         "exec_params": "{ALERT.SENDTO}\n{ALERT.SUBJECT}\n{ALERT.MESSAGE}\n",         "maxattempts": "5",         "attempt_interval": "11s"     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "mediatypeids": [             "8"         ]     },     "id": 1 } ```
he	#### יצירת סוג מדיה של סקריפט  צור סוג מדיה חדש של סקריפט עם ערך מותאם אישית למספר של ניסיונות והמרווח ביניהם.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "mediatype.create",      "params": {          "סוג 1",          "name": "הודעות דחיפה",          "exec_path": "push-notification.sh",          "exec_params": "{ALERT.SENDTO}\n{ALERT.SUBJECT}\n{ALERT.MESSAGE}\n",          "maxattempts": "5",          "attempt_interval": "11 שניות"      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "mediatypeids": [              "8"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a service  Create a service that will be switched to problem state, if at least one child has a problem.  Request:  ```json {     "jsonrpc": "2.0",     "method": "service.create",     "params": {         "name": "Server 1",         "algorithm": 1,         "sortorder": 1     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "serviceids": [             "5"         ]     },     "id": 1 } ```
he	#### יצירת שירות  צור שירות שיועבר למצב בעיה, אם לפחות אחד לילד יש בעיה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "service.create",      "params": {          "name": "שרת 1",          "אלגוריתם": 1,          "סדר": 1      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "serviceids": [              "5"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a slideshow  A slideshow will run automatically if the dashboard contains two or more pages (see [Adding pages](#adding_pages)) and if one of the following is true:  -   The *Start slideshow automatically* option is marked in dashboard     properties -   The dashboard URL contains a `slideshow=1` parameter  The pages rotate according to the intervals given in the properties of the dashboard and individual pages. Click on:  -   *Stop slideshow* - to stop the slideshow -   *Start slideshow* - to start the slideshow  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_page_tabs.png)  Slideshow-related controls are also available in [kiosk mode](#viewing_and_editing_a_dashboard) (where only the page content is shown):  -   ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_stop_kiosk.png) -     stop slideshow -   ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_start_kiosk.png) -     start slideshow -   ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_back_kiosk.png) -     go back one page -   ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_next_kiosk.png) -     go to the next page
he	#### יצירת מצגת  מצגת שקופיות תפעל אוטומטית אם לוח המחוונים מכיל שניים או יותר דפים (ראה [הוספת דפים](#adding_pages)) ואם אחד מהבאים הוא נָכוֹן:  - האפשרות *התחל מצגת שקופיות אוטומטית* מסומנת בלוח המחוונים      נכסים - כתובת האתר של לוח המחוונים מכילה פרמטר `slideshow=1`  הדפים מסתובבים לפי המרווחים הניתנים במאפיינים של לוח המחוונים ודפים בודדים. לחץ על:  - *עצירת מצגת* - כדי לעצור את מצגת השקופיות - *התחלת מצגת* - כדי להפעיל את המצגת  ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/dashboard_page_tabs.png)  פקדים הקשורים למצגת זמינים גם ב-[קיוסק mode](#viewing_and_editing_a_dashboard) (כאשר רק תוכן הדף נמצא מוצג):  - ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_stop_kiosk.png) -      להפסיק את המצגת - ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_start_kiosk.png) -      התחל מצגת - ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_back_kiosk.png) -      לחזור עמוד אחד אחורה - ![](../../../../../assets/en/manual/web_interface/frontend_sections/monitoring/dashboard/slideshow_next_kiosk.png) -      עבור לעמוד הבא

en-us	#### Creating a task  Create a task `check now` for two items. One is an item, the other is a low-level discovery rule.  Request:  ```json {     "jsonrpc": "2.0",     "method": "task.create",     "params": [         {             "type": 6,             "request": {                 "itemid": "10092"             }         },         {             "type": "6",             "request": {                 "itemid": "10093"             }         }     ],     "auth": "700ca65537074ec963db7efabda78259",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "taskids": [             "1",             "2"         ]     },     "id": 1 } ```  Create a task `diagnostic information` task.  Request:  ```json {     "jsonrpc": "2.0",     "method": "task.create",     "params": [         {             "type": 1,             "request": {                 "alerting": {                     "stats": [                         "alerts"                     ],                     "top": {                         "media.alerts": 10                     }                 },                 "lld": {                     "stats": "extend",                     "top": {                         "values": 5                     }                 }             },             "proxy_hostid": 0         }     ],     "auth": "700ca65537074ec963db7efabda78259",     "id": 2 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "taskids": [             "3"         ]     },     "id": 2 } ```
he	#### יצירת משימה  צור משימה 'בדוק עכשיו' עבור שני פריטים. האחד הוא פריט, השני הוא כלל גילוי ברמה נמוכה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "task.create",      "פארמים": [          {              "סוג": 6,              "בקשה": {                  "itemid": "10092"              }          },          {              "type": "6",              "בקשה": {                  "itemid": "10093"              }          }      ],      "auth": "700ca65537074ec963db7efabda78259",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "משימות": [              "1",              "2"          ]      },      "מזהה": 1 } ```  צור משימת 'מידע אבחון' במשימה.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "task.create",      "פארמים": [          {              "סוג 1,              "בקשה": {                  "מתריע": {                      "סטטיסטיקות": [                          "התראות"                      ],                      "חלק עליון": {                          "media.alerts": 10                      }                  },                  "lld": {                      "stats": "להרחיב",                      "חלק עליון": {                          "ערכים": 5                      }                  }              },              "proxy_hostid": 0          }      ],      "auth": "700ca65537074ec963db7efabda78259",      "מזהה": 2 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "משימות": [              "3"          ]      },      "מזהה": 2 } ```

en-us	#### Creating a template  Create a template with tags and link two templates to this template.  Request:  ```json {     "jsonrpc": "2.0",     "method": "template.create",     "params": {         "host": "Linux template",         "groups": {             "groupid": 1         },         "templates": [             {                 "templateid": "11115"             },             {                 "templateid": "11116"             }         ],         "tags": [             {                 "tag": "Host name",                 "value": "{HOST.NAME}"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "templateids": [             "11117"         ]     },     "id": 1 } ```
he	#### יצירת תבנית  צור תבנית עם תגים וקשר שתי תבניות לתבנית זו.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "template.create",      "params": {          "host": "תבנית לינוקס",          "קבוצות": {              "קבוצתי": 1          },          "תבניות": [              {                  "templateid": "11115"              },              {                  "templateid": "11116"              }          ],          "תגים": [              {                  "tag": "שם מארח",                  "value": "{HOST.NAME}"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "templateids": [              "11117"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a template dashboard  Create a template dashboard named “Graphs” with one Graph widget on a single dashboard page.  Request:  ```json {     "jsonrpc": "2.0",     "method": "templatedashboard.create",     "params": {         "templateid": "10318",         "name": "Graphs",         "pages": [             {                 "widgets": [                     {                         "type": "graph",                         "x": 0,                         "y": 0,                         "width": 12,                         "height": 5,                         "view_mode": 0,                         "fields": [                             {                                 "type": 6,                                 "name": "graphid",                                 "value": "1123"                             }                         ]                     }                 ]                              }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "dashboardids": [             "32"         ]     },     "id": 1 } ```
he	#### יצירת לוח מחוונים של תבנית  צור לוח מחוונים של תבנית בשם "גרפים" עם ווידג'ט גרף אחד ב-a דף לוח מחוונים יחיד.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "templatedashboard.create",      "params": {          "templateid": "10318",          "name": "גרפים",          "עמודים": [              {                  "יישומונים": [                      {                          "type": "גרף",                          "x": 0,                          "y": 0,                          "רוחב": 12,                          "גובה": 5,                          "מצב_תצוגה": 0,                          "שדות": [                              {                                  "סוג": 6,                                  "name": "גרפיד",                                  "value": "1123"                              }                          ]                      }                  ]                               }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "dashboardids": [              "32"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a trigger  Create a trigger with a single trigger dependency.  Request:  ```json {     "jsonrpc": "2.0",     "method": "trigger.create",     "params": [         {             "description": "Processor load is too high on {HOST.NAME}",             "expression": "last(/Linux server/system.cpu.load[percpu,avg1])>5",             "dependencies": [                 {                     "triggerid": "17367"                 }             ]         },         {             "description": "Service status",             "expression": "length(last(/Linux server/log[/var/log/system,Service .* has stopped]))<>0",             "dependencies": [                 {                     "triggerid": "17368"                 }             ],             "tags": [                 {                     "tag": "service",                     "value": "{{ITEM.VALUE}.regsub(\"Service (.*) has stopped\", \"\\1\")}"                 },                 {                     "tag": "error",                     "value": ""                 }             ]         }     ],     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "triggerids": [             "17369",             "17370"         ]     },     "id": 1 } ```
he	#### יצירת טריגר  צור טריגר עם תלות טריגר בודד.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "trigger.create",      "פארמים": [          {              "description": "עומס המעבד גבוה מדי ב-{HOST.NAME}",              "expression": "last(/Linux server/system.cpu.load[percpu,avg1])>5",              "תלות": [                  {                      "triggerid": "17367"                  }              ]          },          {              "description": "סטטוס שירות",              "expression": "length(last(/Linux server/log[/var/log/system,Service .* stoped]))<>0",              "תלות": [                  {                      "triggerid": "17368"                  }              ],              "תגים": [                  {                      "tag": "שירות",                      "value": "{{ITEM.VALUE}.regsub(\"השירות (.*) הופסק\", \"\\1\")}"                  },                  {                      "tag": "שגיאה",                      "ערך": ""                  }              ]          }      ],      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "טריגרידים": [              "17369",              "17370"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a trigger prototype  Create a trigger prototype to detect when a file system has less than 20% free disk space.  Request:  ```json {     "jsonrpc": "2.0",     "method": "triggerprototype.create",     "params": {         "description": "Free disk space is less than 20% on volume {#FSNAME}",         "expression": "last(/Zabbix server/vfs.fs.size[{#FSNAME},pfree])<20",         "tags": [             {                 "tag": "volume",                 "value": "{#FSNAME}"             },             {                 "tag": "type",                 "value": "{#FSTYPE}"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "triggerids": [             "17372"         ]     },     "id": 1 } ```
he	#### יצירת אב טיפוס טריגר  צור אב טיפוס טריגר כדי לזהות מתי למערכת קבצים יש פחות מ 20% מקום פנוי בדיסק.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "triggerprototype.create",      "params": {          "description": "שטח דיסק פנוי הוא פחות מ-20% בנפח {#FSNAME}",          "expression": "last(/Zabbix server/vfs.fs.size[{#FSNAME},pfree])<20",          "תגים": [              {                  "tag": "נפח",                  "value": "{#FSNAME}"              },              {                  "tag": "סוג",                  "value": "{#FSTYPE}"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "טריגרידים": [              "17372"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a user  Create a new user, add him to a user group and create a new media for him.  Request:  ```json {     "jsonrpc": "2.0",     "method": "user.create",     "params": {         "username": "John",         "passwd": "Doe123",         "roleid": "5",         "usrgrps": [             {                 "usrgrpid": "7"             }         ],         "medias": [             {                 "mediatypeid": "1",                 "sendto": [                     "support@company.com"                 ],                 "active": 0,                 "severity": 63,                 "period": "1-7,00:00-24:00"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "userids": [             "12"         ]     },     "id": 1 } ```
he	#### יצירת משתמש  צור משתמש חדש, הוסף אותו לקבוצת משתמשים וצור מדיה חדשה עבור אוֹתוֹ.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "user.create",      "params": {          "username": "ג'ון",          "passwd": "Doe123",          "roleid": "5",          "usrgrps": [              {                  "usrgrpid": "7"              }          ],          "מדיה": [              {                  "mediatypeid": "1",                  "לשלוח ל": [                      "support@company.com"                  ],                  "פעיל": 0,                  "חומרה": 63,                  "period": "1-7,00:00-24:00"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "משתמשים": [              "12"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a user group  Create a user group, which denies access to host group "2", and add a user to it.  Request:  ```json {     "jsonrpc": "2.0",     "method": "usergroup.create",     "params": {         "name": "Operation managers",         "rights": {             "permission": 0,             "id": "2"         },         "users": [             {"userid": "12"}         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "usrgrpids": [             "20"         ]     },     "id": 1 } ```
he	#### יצירת קבוצת משתמשים  צור קבוצת משתמשים, שמונעת גישה לקבוצה המארחת "2", והוסף א משתמש אליו.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "usergroup.create",      "params": {          "name": "מנהלי תפעול",          "זכויות": {              "רשות": 0,              "id": "2"          },          "משתמשים": [              {"userid": "12"}          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "usrgrpids": [              "20"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a value map  Create one value map with two mappings.  Request:  ```json {     "jsonrpc": "2.0",     "method": "valuemap.create",     "params": {         "hostid": "50009",         "name": "Service state",         "mappings": [             {                 "type": "1",                 "value": "1",                 "newvalue": "Up"             },             {                 "type": "5",                 "newvalue": "Down"             }         ]     },     "auth": "57562fd409b3b3b9a4d916d45207bbcb",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "valuemapids": [             "1"         ]     },     "id": 1 } ```
he	#### יצירת מפת ערכים  צור מפת ערך אחת עם שני מיפויים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "valuemap.create",      "params": {          "hostid": "50009",          "name": "מצב שירות",          "מיפויים": [              {                  "סוג 1",                  "value": "1",                  "newvalue": "מעלה"              },              {                  "type": "5",                  "newvalue": "למטה"              }          ]      },      "auth": "57562fd409b3b3b9a4d916d45207bbcb",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "valuemapids": [              "1"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a webhook media type  Create a new webhook media type.  Request:  ```json {     "jsonrpc": "2.0",     "method": "mediatype.create",     "params": {         "type": "4",         "name": "Webhook",         "script": "var Webhook = {\r\n    token: null,\r\n    to: null,\r\n    subject: null,\r\n    message: null,\r\n\r\n    sendMessage: function() {\r\n        // some logic\r\n    }\r\n}",         "parameters": [             {                 "name": "Message",                 "value": "{ALERT.MESSAGE}"             },             {                 "name": "Subject",                 "value": "{ALERT.SUBJECT}"             },             {                 "name": "To",                 "value": "{ALERT.SENDTO}"             },             {                 "name": "Token",                 "value": "<Token>"             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "mediatypeids": [             "9"         ]     },     "id": 1 } ```
he	#### יצירת סוג מדיה מסוג webhook  צור סוג מדיה חדש של webhook.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "mediatype.create",      "params": {          "type": "4",          "name": "Webhook",          "script": "var Webhook = {\r\n אסימון: null,\r\n ל: null,\r\n נושא: null,\r\n הודעה: null,\r\n\r\n sendMessage : function() {\r\n // קצת היגיון\r\n }\r\n}",          "פרמטרים": [              {                  "name": "הודעה",                  "value": "{ALERT.MESSAGE}"              },              {                  "name": "נושא",                  "value": "{ALERT.SUBJECT}"              },              {                  "name": "אל",                  "value": "{ALERT.SENDTO}"              },              {                  "name": "אסימון",                  "value": "<אסימון>"              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "mediatypeids": [              "9"          ]      },      "מזהה": 1 } ```

en-us	#### Creating a web scenario  Create a web scenario to monitor the company home page. The scenario will have two steps, to check the home page and the "About" page and make sure they return the HTTP status code 200.  Request:  ```json {     "jsonrpc": "2.0",     "method": "httptest.create",     "params": {         "name": "Homepage check",         "hostid": "10085",         "steps": [             {                 "name": "Homepage",                 "url": "http://example.com",                 "status_codes": "200",                 "no": 1             },             {                 "name": "Homepage / About",                 "url": "http://example.com/about",                 "status_codes": "200",                 "no": 2             }         ]     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "httptestids": [             "5"         ]     },     "id": 1 } ```
he	#### יצירת תרחיש אינטרנט  צור תרחיש אינטרנט לניטור דף הבית של החברה. התרחיש יהיו שני שלבים, לבדוק את דף הבית ואת הדף "אודות" ו ודא שהם מחזירים את קוד מצב ה-HTTP 200.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "httptest.create",      "params": {          "name": "בדיקת דף הבית",          "hostid": "10085",          "צעדים": [              {                  "name": "דף הבית",                  "url": "http://example.com",                  "status_codes": "200",                  "לא": 1              },              {                  "name": "דף הבית / אודות",                  "url": "http://example.com/about",                  "status_codes": "200",                  "לא": 2              }          ]      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "httptestids": [              "5"          ]      },      "מזהה": 1 } ```

en-us	### Creating custom LLD rules  It is also possible to create a completely custom LLD rule, discovering any type of entities - for example, databases on a database server.  To do so, a custom item should be created that returns JSON, specifying found objects and optionally - some properties of them. The amount of macros per entity is not limited - while the built-in discovery rules return either one or two macros (for example, two for filesystem discovery), it is possible to return more.  The required JSON format is best illustrated with an example. Suppose we are running an old Zabbix 1.8 agent (one that does not support "vfs.fs.discovery"), but we still need to discover file systems. Here is a simple Perl script for Linux that discovers mounted file systems and outputs JSON, which includes both file system name and type. One way to use it would be as a UserParameter with key "vfs.fs.discovery\_perl":  ``` {.perl} #!/usr/bin/perl  $first = 1;  print "[\n";  for (`cat /proc/mounts`) {     ($fsname, $fstype) = m/\S+ (\S+) (\S+)/;      print "\t,\n" if not $first;     $first = 0;      print "\t{\n";     print "\t\t\"{#FSNAME}\":\"$fsname\",\n";     print "\t\t\"{#FSTYPE}\":\"$fstype\"\n";     print "\t}\n"; }  print "]\n"; ```  ::: noteimportant Allowed symbols for LLD macro names are **0-9** , **A-Z** , **\_** , **.**\ \ Lowercase letters are not supported in the names. :::  An example of its output (reformatted for clarity) is shown below. JSON for custom discovery checks has to follow the same format.  ``` {.javascript} [     { "{#FSNAME}":"/",                           "{#FSTYPE}":"rootfs"   },     { "{#FSNAME}":"/sys",                        "{#FSTYPE}":"sysfs"    },     { "{#FSNAME}":"/proc",                       "{#FSTYPE}":"proc"     },     { "{#FSNAME}":"/dev",                        "{#FSTYPE}":"devtmpfs" },     { "{#FSNAME}":"/dev/pts",                    "{#FSTYPE}":"devpts"   },     { "{#FSNAME}":"/lib/init/rw",                "{#FSTYPE}":"tmpfs"    },     { "{#FSNAME}":"/dev/shm",                    "{#FSTYPE}":"tmpfs"    },     { "{#FSNAME}":"/home",                       "{#FSTYPE}":"ext3"     },     { "{#FSNAME}":"/tmp",                        "{#FSTYPE}":"ext3"     },     { "{#FSNAME}":"/usr",                        "{#FSTYPE}":"ext3"     },     { "{#FSNAME}":"/var",                        "{#FSTYPE}":"ext3"     },     { "{#FSNAME}":"/sys/fs/fuse/connections",    "{#FSTYPE}":"fusectl"  } ] ```  In previous example it is required that the keys match the LLD macro names used in prototypes, the alternative is to extract LLD macro values using JSONPath `{#FSNAME}` → `$.fsname` and `{#FSTYPE}` → `$.fstype`, thus making such script possible:  ``` {.perl} #!/usr/bin/perl   $first = 1;   print "[\n";   for (`cat /proc/mounts`) {     ($fsname, $fstype) = m/\S+ (\S+) (\S+)/;       print "\t,\n" if not $first;     $first = 0;       print "\t{\n";     print "\t\t\"fsname\":\"$fsname\",\n";     print "\t\t\"fstype\":\"$fstype\"\n";     print "\t}\n"; }   print "]\n"; ```  An example of its output (reformatted for clarity) is shown below. JSON for custom discovery checks has to follow the same format.  ``` {.javascript} [     { "fsname":"/",                           "fstype":"rootfs"   },     { "fsname":"/sys",                        "fstype":"sysfs"    },     { "fsname":"/proc",                       "fstype":"proc"     },     { "fsname":"/dev",                        "fstype":"devtmpfs" },     { "fsname":"/dev/pts",                    "fstype":"devpts"   },     { "fsname":"/lib/init/rw",                "fstype":"tmpfs"    },     { "fsname":"/dev/shm",                    "fstype":"tmpfs"    },     { "fsname":"/home",                       "fstype":"ext3"     },     { "fsname":"/tmp",                        "fstype":"ext3"     },     { "fsname":"/usr",                        "fstype":"ext3"     },     { "fsname":"/var",                        "fstype":"ext3"     },     { "fsname":"/sys/fs/fuse/connections",    "fstype":"fusectl"  } ] ```  Then, in the discovery rule's "Filter" field, we could specify "{\#FSTYPE}" as a macro and "rootfs|ext3" as a regular expression.  ::: noteclassic You don't have to use macro names FSNAME/FSTYPE with custom LLD rules, you are free to use whatever names you like. In case JSONPath is used then LLD row will be an array element that can be an object, but it can be also another array or a value.  :::  Note that, if using a user parameter, the return value is limited to 512 KB. For more details, see [data limits for LLD return values](/manual/discovery/low_level_discovery/notes#data_limits_for_return_values).
he	### יצירת כללי LLD מותאמים אישית  אפשר גם ליצור כלל LLD מותאם אישית לחלוטין, לגלות כל סוג של ישויות - למשל, מסדי נתונים על שרת מסד נתונים.  לשם כך, יש ליצור פריט מותאם אישית שמחזיר JSON, תוך ציון אובייקטים שנמצאו ולחלופין - כמה מאפיינים שלהם. הסכום של פקודות מאקרו לכל ישות אינן מוגבלות - בעוד שהגילוי המובנה שולט החזר פקודת מאקרו אחת או שתיים (לדוגמה, שתיים עבור מערכת הקבצים גילוי), אפשר להחזיר יותר.  פורמט JSON הנדרש מומחש בצורה הטובה ביותר עם דוגמה. נניח שאנחנו מפעילים סוכן Zabbix 1.8 ישן (כזה שאינו תומך "vfs.fs.discovery"), אבל אנחנו עדיין צריכים לגלות מערכות קבצים. הנה סקריפט פשוט של Perl עבור לינוקס שמגלה מערכות קבצים רכובות ו פלט JSON, הכולל גם שם וגם סוג של מערכת הקבצים. דרך אחת ל השימוש בו יהיה כ-UserParameter עם המפתח "vfs.fs.discovery\_perl":  ``` {.perl} #!/usr/bin/perl  $first = 1;  הדפס "[\n";  עבור (`cat /proc/mounts`) {      ($fsname, $fstype) = m/\S+ (\S+) (\S+)/;       הדפס "\t,\n" אם לא $first;      $first = 0;       הדפס "\t{\n";      הדפס "\t\t\"{#FSNAME}\":\"$fsname\",\n";      הדפס "\t\t\"{#FSTYPE}\":\"$fstype\"\n";      הדפס "\t}\n"; }  הדפס "]\n"; ```  ::: שימו לב חשוב הסמלים המותרים עבור שמות מאקרו LLD הם **0-9** , **א-ת** , **\_** , **.**\ \ אותיות קטנות אינן נתמכות בשמות. :::  דוגמה לפלט שלו (פורמט מחדש לצורך הבהירות) מוצגת להלן. JSON עבור בדיקות גילוי מותאמות אישית חייב לפעול באותו פורמט.  ``` {.javascript} [      { "{#FSNAME}":"/", "{#FSTYPE}":"rootfs" },      { "{#FSNAME}":"/sys", "{#FSTYPE}":"sysfs" },      { "{#FSNAME}":"/proc", "{#FSTYPE}":"proc" },      { "{#FSNAME}":"/dev", "{#FSTYPE}":"devtmpfs" },      { "{#FSNAME}":"/dev/pts", "{#FSTYPE}":"devpts" },      { "{#FSNAME}":"/lib/init/rw", "{#FSTYPE}":"tmpfs" },      { "{#FSNAME}":"/dev/shm", "{#FSTYPE}":"tmpfs" },      { "{#FSNAME}":"/home", "{#FSTYPE}":"ext3" },      { "{#FSNAME}":"/tmp", "{#FSTYPE}":"ext3" },      { "{#FSNAME}":"/usr", "{#FSTYPE}":"ext3" },      { "{#FSNAME}":"/var", "{#FSTYPE}":"ext3" },      { "{#FSNAME}":"/sys/fs/fuse/connections", "{#FSTYPE}":"fusectl" } ] ```  בדוגמה הקודמת נדרש שהמפתחות יתאימו למאקרו LLD שמות המשמשים באבות טיפוס, החלופה היא לחלץ ערכי מאקרו LLD באמצעות JSONPath `{#FSNAME}` → `$.fsname` ו-`{#FSTYPE}` → `$.fstype`, ובכך מאפשר תסריט כזה:  ``` {.perl} #!/usr/bin/perl   $first = 1;   הדפס "[\n";   עבור (`cat /proc/mounts`) {      ($fsname, $fstype) = m/\S+ (\S+) (\S+)/;        הדפס "\t,\n" אם לא $first;      $first = 0;        הדפס "\t{\n";      הדפס "\t\t\"fsname\":\"$fsname\",\n";      הדפס "\t\t\"fstype\":\"$fstype\"\n";      הדפס "\t}\n"; }   הדפס "]\n"; ```  דוגמה לפלט שלו (פורמט מחדש לצורך הבהירות) מוצגת להלן. JSON עבור בדיקות גילוי מותאמות אישית חייב לפעול באותו פורמט.  ``` {.javascript} [      { "fsname":"/", "fstype":"rootfs" },      { "fsname":"/sys", "fstype":"sysfs" },      { "fsname":"/proc", "fstype":"proc" },      { "fsname":"/dev", "fstype":"devtmpfs" },      { "fsname":"/dev/pts", "fstype":"devpts" },      { "fsname":"/lib/init/rw", "fstype":"tmpfs" },      { "fsname":"/dev/shm", "fstype":"tmpfs" },      { "fsname":"/home", "fstype":"ext3" },      { "fsname":"/tmp", "fstype":"ext3" },      { "fsname":"/usr", "fstype":"ext3" },      { "fsname":"/var", "fstype":"ext3" },      { "fsname":"/sys/fs/fuse/connections", "fstype":"fusectl" } ] ```  לאחר מכן, בשדה "מסנן" של כלל הגילוי, נוכל לציין "{\#FSTYPE}" כמאקרו ו-"rootfs|ext3" כביטוי רגולרי.  ::: noteclassic אינך חייב להשתמש בשמות מאקרו FSNAME/FSTYPE עם מותאם אישית חוקי LLD, אתה חופשי להשתמש בכל שמות שאתה אוהב. במקרה של JSONPath משמש אז שורה LLD תהיה אלמנט מערך שיכול להיות אובייקט, אבל זה יכול להיות גם מערך אחר או ערך. :::  שימו לב שאם משתמשים בפרמטר משתמש, ערך ההחזרה מוגבל ל-512 KB. לפרטים נוספים, ראה [מגבלות נתונים עבור החזרת LLD ערכים](/manual/discovery/low_level_discovery/notes#data_limits_for_return_values).

en-us	##### Creating database  [Create](/manual/appendix/install/db_scripts) a separate database for Zabbix proxy.  Zabbix server and Zabbix proxy cannot use the same database. If they are installed on the same host, the proxy database must have a different name.
he	##### יצירת מסד נתונים  [צור](/manual/appendix/install/db_scripts) מסד נתונים נפרד עבור פרוקסי של Zabbix.  שרת Zabbix ו-Proxy Zabbix אינם יכולים להשתמש באותו מסד נתונים. אם הם מותקן על אותו מארח, מסד הנתונים של ה-proxy חייב להיות שונה שֵׁם.

en-us	##### Creating database  [Create](/manual/appendix/install/db_scripts) a separate database for Zabbix proxy.  Zabbix server and Zabbix proxy cannot use the same database. If they are installed on the same host, the proxy database must have a different name.
he	##### יצירת מסד נתונים  [צור](/manual/appendix/install/db_scripts) מסד נתונים נפרד עבור פרוקסי של Zabbix.  שרת Zabbix ו-Proxy Zabbix אינם יכולים להשתמש באותו מסד נתונים. אם הם מותקן על אותו מארח, מסד הנתונים של ה-proxy חייב להיות שונה שֵׁם.

en-us	##### Creating database  [Create](/manual/appendix/install/db_scripts) a separate database for Zabbix proxy.  Zabbix server and Zabbix proxy cannot use the same database. If they are installed on the same host, the proxy database must have a different name.
he	##### יצירת מסד נתונים  [צור](/manual/appendix/install/db_scripts) מסד נתונים נפרד עבור פרוקסי של Zabbix.  שרת Zabbix ו-Proxy Zabbix אינם יכולים להשתמש באותו מסד נתונים. אם הם מותקן על אותו מארח, מסד הנתונים של ה-proxy חייב להיות שונה שֵׁם.

en-us	#### Creating database  For Zabbix [server](/manual/concepts/server) and [proxy](/manual/concepts/proxy) daemons a database is required. It is not needed to run Zabbix [agent](/manual/concepts/agent).  ::: notewarning Separate databases are needed for Zabbix server and Zabbix proxy; they cannot use the same database. Therefore, if they are installed on the same host, their databases must be created with different names! :::  Create the database using the provided instructions for [MySQL](/manual/appendix/install/db_scripts#mysql) or [PostgreSQL](/manual/appendix/install/db_scripts#postgresql).
he	#### יצירת מסד נתונים  עבור Zabbix [שרת](/manual/concepts/server) ו [proxy](/manual/concepts/proxy) דמונים נדרש מסד נתונים. זה אין צורך להפעיל את Zabbix [סוכן](/manual/concepts/agent).  ::: הערה אזהרה דרושים מסדי נתונים נפרדים עבור שרת Zabbix ו פרוקסי Zabbix; הם לא יכולים להשתמש באותו מסד נתונים. לכן, אם הם כן מותקן על אותו מארח, יש ליצור את מסדי הנתונים שלהם שמות שונים! :::  צור את מסד הנתונים באמצעות ההוראות שסופקו עבור [MySQL](/manual/appendix/install/db_scripts#mysql) או [PostgreSQL](/manual/appendix/install/db_scripts#postgresql).

en-us	#### Creating dependent item  Create a dependent item for the master item with ID 24759. Only dependencies on the same host are allowed, therefore master and the dependent item should have the same hostid.  Request:  ```json {     "jsonrpc": "2.0",     "method": "item.create",     "params": {       "hostid": "30074",       "name": "Dependent test item",       "key_": "dependent.item",       "type": 18,       "master_itemid": "24759",       "value_type": 2     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "44211"         ]     },     "id": 1 } ```
he	#### יצירת פריט תלוי  צור פריט תלוי עבור פריט המאסטר עם מזהה 24759. בלבד מותרות תלות באותו מארח, לכן מאסטר וה- לפריט תלוי צריך להיות אותו hosttid.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "item.create",      "params": {        "hostid": "30074",        "name": "פריט בדיקה תלוי",        "key_": "dependent.item",        "סוג": 18,        "master_itemid": "24759",        "סוג_ערך": 2      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "44211"          ]      },      "מזהה": 1 } ```

en-us	#### Creating dependent item prototype  Create Dependent item prototype for Master item prototype with ID 44211. Only dependencies on same host (template/discovery rule) are allowed, therefore Master and Dependent item should have same hostid and ruleid.  Request:  ```json {     "jsonrpc": "2.0",     "method": "itemprototype.create",     "params": {       "hostid": "10001",       "ruleid": "27665",       "name": "Dependent test item prototype",       "key_": "dependent.prototype",       "type": 18,       "master_itemid": "44211",       "value_type": 3     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "itemids": [             "44212"         ]     },     "id": 1 } ```
he	#### יצירת אב טיפוס של פריט תלוי  צור אב טיפוס של פריט תלוי עבור אב טיפוס של פריט ראשי עם מזהה 44211. רק תלות באותו מארח (כלל תבנית/גילוי) מותרות, לכן פריט מאסטר ותלוי צריכים להיות בעלי אותו hostid ו- ruleid.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "itemprototype.create",      "params": {        "hostid": "10001",        "ruleid": "27665",        "name": "אב-טיפוס של פריט בדיקה תלוי",        "key_": "dependent.prototype",        "סוג": 18,        "master_itemid": "44211",        "סוג_ערך": 3      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "itemids": [              "44212"          ]      },      "מזהה": 1 } ```

en-us	#### Creating interfaces  Create an interface on two hosts.  Request:  ```json {     "jsonrpc": "2.0",     "method": "hostinterface.massadd",     "params": {         "hosts": [             {                 "hostid": "30050"             },             {                 "hostid": "30052"             }         ],         "interfaces": {             "dns": "",             "ip": "127.0.0.1",             "main": 0,             "port": "10050",             "type": 1,             "useip": 1         }     },     "auth": "038e1d7b1735c6a5436ee9eae095879e",     "id": 1 } ```  Response:  ```json {     "jsonrpc": "2.0",     "result": {         "interfaceids": [             "30069",             "30070"         ]     },     "id": 1 } ```
he	#### יצירת ממשקים  צור ממשק בשני מארחים.  בַּקָשָׁה:  ``` json {      "jsonrpc": "2.0",      "method": "hostinterface.massadd",      "params": {          "מארחים": [              {                  "hostid": "30050"              },              {                  "hostid": "30052"              }          ],          "ממשקים": {              "dns": "",              "ip": "127.0.0.1",              "ראשי": 0,              "port": "10050",              "סוג 1,              "useip": 1          }      },      "auth": "038e1d7b1735c6a5436ee9eae095879e",      "מזהה": 1 } ```  תְגוּבָה:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "interfaceids": [              "30069",              "30070"          ]      },      "מזהה": 1 } ```

en-us	#### Creating multiple triggers  So if create methods accept arrays, we can add multiple [triggers](/manual/api/reference/trigger/object) like so:  ```json {     "jsonrpc": "2.0",     "method": "trigger.create",     "params": [         {             "description": "Processor load is too high on {HOST.NAME}",             "expression": "last(/Linux server/system.cpu.load[percpu,avg1])>5",         },         {             "description": "Too many processes on {HOST.NAME}",             "expression": "avg(/Linux server/proc.num[],5m)>300",         }     ],     "auth": "0424bd59b807674191e7d77572075f33",     "id": 4 } ```  A successful response will contain the IDs of the newly created triggers:  ```json {     "jsonrpc": "2.0",     "result": {         "triggerids": [             "17369",             "17370"         ]     },     "id": 4 } ```
he	#### יצירת טריגרים מרובים  אז אם יצירת שיטות יקבלו מערכים, נוכל להוסיף מרובים [triggers](/manual/api/reference/trigger/object) כך:  ``` json {      "jsonrpc": "2.0",      "method": "trigger.create",      "פארמים": [          {              "description": "עומס המעבד גבוה מדי ב-{HOST.NAME}",              "expression": "last(/Linux server/system.cpu.load[percpu,avg1])>5",          },          {              "description": "יותר מדי תהליכים ב-{HOST.NAME}",              "expression": "avg(/Linux server/proc.num[],5m)>300",          }      ],      "auth": "0424bd59b807674191e7d77572075f33",      "מזהה": 4 } ```  תגובה מוצלחת תכיל את המזהים של הקוד החדש שנוצר טריגרים:  ``` json {      "jsonrpc": "2.0",      "תוצאה": {          "טריגרידים": [              "17369",              "17370"          ]      },      "מזהה": 4 } ```

en-us	##### - Credentials (login:password)  System:  -   root:zabbix  Zabbix frontend:  -   Admin:zabbix  Database:  -   root:<random> -   zabbix:<random>  ::: noteclassic Database passwords are randomly generated during the installation process.\ Root password is stored inside the /root/.my.cnf file. It is not required to input a password under the "root" account. :::  To change the database user password, changes have to be made in the following locations:  -   MySQL; -   /etc/zabbix/zabbix\_server.conf; -   /etc/zabbix/web/zabbix.conf.php.  ::: noteclassic  Separate users `zabbix_srv` and `zabbix_web` are defined for the server and the frontend respectively.  :::
he	##### - אישורים (כניסה:סיסמה)  מערכת:  - root:zabbix  חזית Zabbix:  - אדמין:zabbix  מאגר מידע:  - root:<אקראי> - zabbix:<אקראי>  ::: noteclassic סיסמאות מסד נתונים נוצרות באופן אקראי במהלך תהליך ההתקנה.\ סיסמת השורש מאוחסנת בתוך הקובץ /root/.my.cnf. זה לא נדרש להזין סיסמה תחת חשבון "שורש". :::  כדי לשנות את סיסמת המשתמש של מסד הנתונים, יש לבצע שינויים ב- המיקומים הבאים:  - MySQL; - /etc/zabbix/zabbix\_server.conf; - /etc/zabbix/web/zabbix.conf.php.  ::: noteclassic   משתמשים נפרדים `zabbix_srv` ו-`zabbix_web` מוגדרים עבור השרת והחזית בהתאמה. :::

en-us	### Critical  To complete successful Zabbix server upgrade on MySQL and MariaDB, you may require to set `GLOBAL log_bin_trust_function_creators = 1` in MySQL  if binary logging is enabled, there are no superuser privileges and `log_bin_trust_function_creators = 1` is not set in MySQL configuration file.   To set the variable using the MySQL console, run:      mysql> SET GLOBAL log_bin_trust_function_creators = 1;  Once the upgrade has been successfully completed, `log_bin_trust_function_creators` can be disabled:      mysql> SET GLOBAL log_bin_trust_function_creators = 0;
he	### קריטי  כדי להשלים שדרוג מוצלח של שרת Zabbix ב-MySQL ו-MariaDB, ייתכן שתצטרך להגדיר 'GLOBAL log_bin_trust_function_creators = 1' ב-MySQL אם רישום בינארי מופעל, אין הרשאות משתמש-על ו-'log_bin_trust_function_creators = 1' אינו מוגדר בקובץ התצורה של MySQL.  כדי להגדיר את המשתנה באמצעות מסוף MySQL, הפעל:       mysql> SET GLOBAL log_bin_trust_function_creators = 1;  לאחר השלמת השדרוג בהצלחה, ניתן להשבית את `log_bin_trust_function_creators`:       mysql> SET GLOBAL log_bin_trust_function_creators = 0;

en-us	#### CRL expired or expires during server operation  [*OpenSSL*]{.underline}, in server log:  -   before expiration:  ```{=html} <!-- --> ```     cannot connect to proxy "proxy-openssl-1.0.1e": TCP successful, cannot establish TLS to [[127.0.0.1]:20004]:\         SSL_connect() returned SSL_ERROR_SSL: file s3_clnt.c line 1253: error:14090086:\         SSL routines:ssl3_get_server_certificate:certificate verify failed:\         TLS write fatal alert "certificate revoked"  -   after expiration:  ```{=html} <!-- --> ```     cannot connect to proxy "proxy-openssl-1.0.1e": TCP successful, cannot establish TLS to [[127.0.0.1]:20004]:\         SSL_connect() returned SSL_ERROR_SSL: file s3_clnt.c line 1253: error:14090086:\         SSL routines:ssl3_get_server_certificate:certificate verify failed:\         TLS write fatal alert "certificate expired"  The point here is that with valid CRL a revoked certificate is reported as "certificate revoked". When CRL expires the error message changes to "certificate expired" which is quite misleading.  [*GnuTLS*]{.underline}, in server log:  -   before and after expiration the same:  ```{=html} <!-- --> ```     cannot connect to proxy "proxy-openssl-1.0.1e": TCP successful, cannot establish TLS to [[127.0.0.1]:20004]:\           invalid peer certificate: The certificate is NOT trusted. The certificate chain is revoked.
he	#### CRL פג או פג במהלך פעולת השרת  [*OpenSSL*]{.underline}, ביומן השרת:  - לפני התפוגה:  ```{=html} <!-- --> ```      לא יכול להתחבר ל-proxy "proxy-openssl-1.0.1e": TCP הצליח, לא יכול להקים TLS ל-[[127.0.0.1]:20004]:\          SSL_connect() החזיר SSL_ERROR_SSL: קובץ s3_clnt.c שורה 1253: error:14090086:\          שגרות SSL:ssl3_get_server_certificate:certificate אימות נכשל:\          TLS כותבת התראה קטלנית "האישור בוטל"  - לאחר התפוגה:  ```{=html} <!-- --> ```      לא יכול להתחבר ל-proxy "proxy-openssl-1.0.1e": TCP הצליח, לא יכול להקים TLS ל-[[127.0.0.1]:20004]:\          SSL_connect() החזיר SSL_ERROR_SSL: קובץ s3_clnt.c שורה 1253: error:14090086:\          שגרות SSL:ssl3_get_server_certificate:certificate אימות נכשל:\          TLS כותב התראה קטלנית "פג תוקף האישור"  הנקודה כאן היא שעם CRL חוקי מדווח על אישור שבוטל כ"אישור מבוטל". כאשר ה-CRL יפוג הודעת השגיאה משתנה ל "פג תוקף האישור" וזה די מטעה.  [*GnuTLS*]{.underline}, ביומן השרת:  - לפני ואחרי תפוגה זהה:  ```{=html} <!-- --> ```      לא יכול להתחבר ל-proxy "proxy-openssl-1.0.1e": TCP הצליח, לא יכול להקים TLS ל-[[127.0.0.1]:20004]:\            אישור עמית לא חוקי: האישור אינו מהימן. שרשרת האישורים מבוטלת.

en-us	### Cryptography
he	### קריפטוגרפיה

en-us	##### Custom copyright notice  To set a custom copyright notice, add `BRAND_FOOTER` to the array from the first listing. Please be aware that HTML is not supported here. Setting `BRAND_FOOTER` to an empty string will hide the copyright notice completely (but the footer will stay in place).  ```php 'BRAND_FOOTER' => '{text}', ```
he	##### הודעת זכויות יוצרים מותאמת אישית  כדי להגדיר הודעת זכויות יוצרים מותאמת אישית, הוסף 'BRAND_FOOTER' למערך מהרישום הראשון. אנא שים לב ש-HTML אינו נתמך כאן. הגדרה של 'BRAND_FOOTER' למחרוזת ריקה תסתיר את הודעת זכויות היוצרים לחלוטין (אך הכותרת התחתונה תישאר במקומה).  ```php 'BRAND_FOOTER' => '{טקסט}', ```

en-us	##### Custom help location  To replace the default *Help* link with a link of your choice, add `BRAND_HELP_URL` to the array from the first listing.  ```php 'BRAND_HELP_URL' => '{URL}' ```
he	##### מיקום עזרה מותאם אישית  כדי להחליף את ברירת המחדל של קישור *עזרה* בקישור לבחירתך, הוסף 'BRAND_HELP_URL' למערך מהרישום הראשון.  ```php 'BRAND_HELP_URL' => '{URL}' ```

en-us	### Custom interface details  The details object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**version**<br>(required)|integer|SNMP interface version.<br><br>Possible values are:<br>1 - SNMPv1;<br>2 - SNMPv2c;<br>3 - SNMPv3| |bulk|integer|Whether to use bulk SNMP requests.<br><br>Possible values are:<br>0 - don't use bulk requests;<br>1 - *(default)* - use bulk requests.| |community|string|SNMP community. Used only by SNMPv1 and SNMPv2 interfaces.| |securityname|string|SNMPv3 security name. Used only by SNMPv3 interfaces.| |securitylevel|integer|SNMPv3 security level. Used only by SNMPv3 interfaces.<br><br>Possible values are:<br>0 - *(default)* - noAuthNoPriv;<br>1 - authNoPriv;<br>2 - authPriv.| |authpassphrase|string|SNMPv3 authentication passphrase. Used only by SNMPv3 interfaces.| |privpassphrase|string|SNMPv3 privacy passphrase. Used only by SNMPv3 interfaces.| |authprotocol|integer|SNMPv3 authentication protocol. Used only by SNMPv3 interfaces.<br><br>Possible values are:<br>0 - *(default)* - MD5;<br>1 - SHA1;<br>2 - SHA224;<br>3 - SHA256;<br>4 - SHA384;<br>5 - SHA512.| |privprotocol|integer|SNMPv3 privacy protocol. Used only by SNMPv3 interfaces.<br><br>Possible values are:<br>0 - *(default)* - DES;<br>1 - AES128;<br>2 - AES192;<br>3 - AES256;<br>4 - AES192C;<br>5 - AES256C.| |contextname|string|SNMPv3 context name. Used only by SNMPv3 interfaces.|
he	### פרטי ממשק מותאם אישית  לאובייקט הפרטים יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**גרסה**<br>(נדרש)|מספר שלם|גרסת ממשק SNMP.<br><br>ערכים אפשריים הם:<br>1 - SNMPv1;<br>2 - SNMPv2c;<br>3 - SNMPv3| |bulk|integer|האם להשתמש בבקשות SNMP בכמות גדולה.<br><br>ערכים אפשריים הם:<br>0 - אל תשתמש בבקשות בכמות גדולה;<br>1 - *(ברירת מחדל)* - השתמש בבקשות בכמות גדולה.| |קהילה|מחרוזת|קהילת SNMP. בשימוש רק על ידי ממשקי SNMPv1 ו-SNMPv2.| |securityname|string|שם אבטחה SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.| |רמת אבטחה|מספר שלם|רמת אבטחה SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.<br><br>ערכים אפשריים הם:<br>0 - *(ברירת מחדל)* - noAuthNoPriv;<br>1 - authNoPriv;<br>2 - authPriv.| |authpassphrase|string|משפט סיסמה לאימות SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.| |privpassphrase|string|משפט סיסמה פרטיות של SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.| |authprotocol|שלם|פרוטוקול אימות SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.<br><br>ערכים אפשריים הם:<br>0 - *(ברירת מחדל)* - MD5;<br>1 - SHA1;<br>2 - SHA224;<br>3 - SHA256; <br>4 - SHA384;<br>5 - SHA512.| |privprotocol|שלם|פרוטוקול פרטיות SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.<br><br>ערכים אפשריים הם:<br>0 - *(ברירת מחדל)* - DES;<br>1 - AES128;<br>2 - AES192;<br>3 - AES256; <br>4 - AES192C;<br>5 - AES256C.| |contextname|string|שם הקשר SNMPv3. בשימוש רק על ידי ממשקי SNMPv3.|

en-us	### Custom interface  The custom interface object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |dns|string|DNS name used by the interface.<br><br>**Required** if the connection is made via DNS. Can contain macros.| |ip|string|IP address used by the interface.<br><br>**Required** if the connection is made via IP. Can contain macros.| |**main**<br>(required)|integer|Whether the interface is used as default on the host. Only one interface of some type can be set as default on a host.<br><br>Possible values are:<br>0 - not default;<br>1 - default.| |**port**<br>(required)|string|Port number used by the interface. Can contain user and LLD macros.| |**type**<br>(required)|integer|Interface type.<br><br>Possible values are:<br>1 - agent;<br>2 - SNMP;<br>3 - IPMI;<br>4 - JMX.<br>| |**useip**<br>(required)|integer|Whether the connection should be made via IP.<br><br>Possible values are:<br>0 - connect using host DNS name;<br>1 - connect using host IP address for this host interface.| |details|array|Additional object for interface. **Required** if interface 'type' is SNMP.|
he	### ממשק מותאם אישית  לאובייקט הממשק המותאם אישית יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |dns|string|שם DNS המשמש את הממשק.<br><br>**חובה** אם החיבור מתבצע באמצעות DNS. יכול להכיל פקודות מאקרו.| |ip|string|כתובת IP המשמשת את הממשק.<br><br>**חובה** אם החיבור מתבצע באמצעות IP. יכול להכיל פקודות מאקרו.| |**ראשי**<br>(נדרש)|מספר שלם|האם הממשק משמש כברירת מחדל במארח. ניתן להגדיר רק ממשק אחד מסוג כלשהו כברירת מחדל במארח.<br><br>ערכים אפשריים הם:<br>0 - לא ברירת מחדל;<br>1 - ברירת מחדל.| |**יציאה**<br>(נדרש)|string|מספר יציאה המשמש את הממשק. יכול להכיל פקודות מאקרו משתמש ו-LLD.| |**סוג**<br>(נדרש)|מספר שלם|סוג ממשק.<br><br>ערכים אפשריים הם:<br>1 - סוכן;<br>2 - SNMP;<br>3 - IPMI;< br>4 - JMX.<br>| |**useip**<br>(נדרש)|מספר שלם|האם יש לבצע את החיבור באמצעות IP.<br><br>ערכים אפשריים הם:<br>0 - התחבר באמצעות שם DNS מארח;<br>1 - התחבר באמצעות כתובת IP מארח עבור ממשק מארח זה.| |פרטים|מערך|אובייקט נוסף לממשק. **חובה** אם 'סוג' הממשק הוא SNMP.|

en-us	##### Custom logo  To use a custom logo, add the following line to the array from the previous listing:  ```php 'BRAND_LOGO' => '{Path to an image on the disk or URL}', ```  Note that the path to the image on the disk should be relative to the Zabbix frontend root directory. So, for example, if the image is located in the same directory as the *brand.conf.php* file, then the path to the image should be: `'./local/conf/custom_logo.png'`.  There are two additional images of the Zabbix logo that can be overridden:  -   `BRAND_LOGO_SIDEBAR` - displayed when the sidebar is expanded; -   `BRAND_LOGO_SIDEBAR_COMPACT` - displayed when the sidebar is collapsed.  To override:  ```php 'BRAND_LOGO_SIDEBAR' => '{Path to an image on the disk or URL}', 'BRAND_LOGO_SIDEBAR_COMPACT' => '{Path to an image on the disk or URL}', ```  Any image format supported by modern browsers can be used: JPG, PNG, SVG, BMP, WebP, and GIF.  ::: noteclassic Custom logos will not be scaled, resized or modified in any other way, and will be displayed in their original size and proportions, except for the `BRAND_LOGO_SIDEBAR_COMPACT` that will be cropped (width: 24px; height: the same as `BRAND_LOGO_SIDEBAR`) to fit the collapsed sidebar. For reference, the following dimensions are used for Zabbix logos:<br><br>  -   `BRAND_LOGO`: 114x30px -   `BRAND_LOGO_SIDEBAR`: 91x24px -   `BRAND_LOGO_SIDEBAR_COMPACT`: 24x24px :::
he	##### לוגו מותאם אישית  כדי להשתמש בלוגו מותאם אישית, הוסף את השורה הבאה למערך מהרישום הקודם:  `` `php 'BRAND_LOGO' => '{נתיב לתמונה בדיסק או בכתובת האתר}', ```  שימו לב שהנתיב לתמונה בדיסק צריך להיות ביחס לספריית השורש של Zabbix Frontend. כך, למשל, אם התמונה ממוקמת באותה ספרייה כמו קובץ *brand.conf.php*, אז הנתיב לתמונה צריך להיות: `'./local/conf/custom_logo.png'`.  ישנן שתי תמונות נוספות של הלוגו של Zabbix שניתן לעקוף:  - `BRAND_LOGO_SIDEBAR` - מוצג כאשר סרגל הצד מורחב; - `BRAND_LOGO_SIDEBAR_COMPACT` - מוצג כאשר סרגל הצד מכווץ.  כדי לעקוף:  `` `php 'BRAND_LOGO_SIDEBAR' => '{נתיב לתמונה בדיסק או ב-URL}', 'BRAND_LOGO_SIDEBAR_COMPACT' => '{נתיב לתמונה בדיסק או בכתובת האתר}', ```  ניתן להשתמש בכל פורמט תמונה הנתמך על ידי דפדפנים מודרניים: JPG, PNG, SVG, BMP, WebP ו-GIF.  ::: noteclassic סמלי לוגו מותאמים אישית לא יעברו קנה מידה, שינוי גודל או שינוי בכל דרך אחרת, והם יוצגו בגודלם ובפרופורציות המקוריות שלהם, מלבד `BRAND_LOGO_SIDEBAR_COMPACT` שיחתוך (רוחב: 24px; גובה: זהה ל-`BRAND_LOGO_SIDEBAR`) כדי להתאים לסרגל הצד המכווץ. לעיון, הממדים הבאים משמשים עבור סמלי לוגו של Zabbix:<br><br>  - `BRAND_LOGO`: 114x30 פיקסלים - `BRAND_LOGO_SIDEBAR`: 91x24px - `BRAND_LOGO_SIDEBAR_COMPACT`: 24x24px :::

en-us	#### Custom macros  The **LLD macros** tab allows to specify custom low-level discovery macros.  Custom macros are useful in cases when the returned JSON does not have the required macros already defined. So, for example:  -   The native `vfs.fs.discovery` key for filesystem discovery returns a     JSON with some pre-defined LLD macros such as {\#FSNAME},     {\#FSTYPE}. These macros can be used in item, trigger prototypes     (see subsequent sections of the page) directly; defining custom     macros is not needed; -   The `vfs.fs.get` agent item also returns a JSON with [filesystem     data](/manual/discovery/low_level_discovery/examples/mounted_filesystems),     but without any pre-defined LLD macros. In this case you may define     the macros yourself, and map them to the values in the JSON using     JSONPath:  ![](../../../assets/en/manual/discovery/low_level_discovery/lld_fs_c.png)  The extracted values can be used in discovered items, triggers, etc. Note that values will be extracted from the result of discovery and any preprocessing steps so far.  |Parameter|Description| |--|--------| |*LLD macro*|Name of the low-level discovery macro, using the following syntax: {\#MACRO}.| |*JSONPath*|Path that is used to extract LLD macro value from a LLD row, using JSONPath syntax.<br>For example, `$.foo` will extract "bar" and "baz" from this JSON: `[{"foo":"bar"}, {"foo":"baz"}]`<br>The values extracted from the returned JSON are used to replace the LLD macros in item, trigger, etc. prototype fields.<br>JSONPath can be specified using the dot notation or the bracket notation. Bracket notation should be used in case of any special characters and Unicode, like `$['unicode + special chars #1']['unicode + special chars #2']`.|
he	#### פקודות מאקרו מותאמות אישית  הכרטיסייה **פקודות מאקרו LLD** מאפשרת לציין גילוי מותאם אישית ברמה נמוכה פקודות מאקרו.  פקודות מאקרו מותאמות אישית שימושיות במקרים שבהם אין ל-JSON המוחזר פקודות המאקרו הנדרשות כבר מוגדרות. אז, למשל:  - מפתח `vfs.fs.discovery` המקורי לגילוי מערכת קבצים מחזיר א      JSON עם כמה פקודות מאקרו LLD מוגדרות מראש כגון {\#FSNAME},      {\#FSTYPE}. ניתן להשתמש בפקודות מאקרו אלו בפריט, טריגר אבות טיפוס      (ראה חלקים הבאים של הדף) ישירות; הגדרת מנהג      אין צורך בפקודות מאקרו; - פריט הסוכן `vfs.fs.get` מחזיר גם JSON עם [מערכת קבצים      data](/manual/discovery/low_level_discovery/examples/mounted_filesystems),      אך ללא פקודות מאקרו LLD מוגדרות מראש. במקרה זה אתה יכול להגדיר      את פקודות המאקרו בעצמך, ומפה אותן לערכים ב-JSON באמצעות      JSONPath:  ![](../../../assets/en/manual/discovery/low_level_discovery/lld_fs_c.png)  ניתן להשתמש בערכים שחולצו בפריטים שהתגלו, טריגרים וכו'. שים לב שערכים ייחלצו מתוצאת הגילוי וכל שלבי עיבוד מקדים עד כה.  |פרמטר|תיאור| |--|--------| |*LLD macro*|שם מאקרו הגילוי ברמה נמוכה, תוך שימוש בתחביר הבא: {\#MACRO}.| |*JSONPath*|נתיב המשמש לחילוץ ערך מאקרו LLD משורת LLD, באמצעות תחביר JSONPath.<br>לדוגמה, `$.foo` יחלץ "bar" ו-"baz" מה-JSON הזה: `[{ "foo":"bar"}, {"foo":"baz"}]`<br>הערכים שחולצו מה-JSON המוחזר משמשים להחלפת פקודות המאקרו של LLD בשדות אב-טיפוס של פריט, טריגר וכו'.<br> ניתן לציין JSONPath באמצעות סימון הנקודות או סימון הסוגר. יש להשתמש בסימון סוגריים במקרה של תווים מיוחדים ו-Unicode, כמו `$['unicode + תווים מיוחדים #1']['unicode + תווים מיוחדים #2']`.|

en-us	#### Custom script limit  Available custom script length depends on the database used:  |Database|Limit in characters|Limit in bytes| |---|---|---| |**MySQL**|65535|65535| |**Oracle Database**|2048|4000| |**PostgreSQL**|65535|not limited| |**SQLite (only Zabbix proxy)**|65535|not limited|
he	#### מגבלת סקריפט מותאם אישית  אורך סקריפט מותאם אישית זמין תלוי במסד הנתונים המשמש:  |מסד נתונים|הגבלה בתווים|הגבלה בבתים| |---|---|---| |**MySQL**|65535|65535| |**מסד נתונים של אורקל**|2048|4000| |**PostgreSQL**|65535|לא מוגבל| |**SQLite (פרוקסי של Zabbix בלבד)**|65535|לא מוגבל|

en-us	#### dashboard Changes:\ [ZBXNEXT-6999](https://support.zabbix.com/browse/ZBXNEXT-6999) added new widget type `slareport` and widget field types *(9 - Service, 10 - SLA)*.\ [ZBXNEXT-6966](https://support.zabbix.com/browse/ZBXNEXT-6966) added new widget type `item`.\
he	#### dashboard שינויים:\ [ZBXNEXT-6999](https://support.zabbix.com/browse/ZBXNEXT-6999) נוסף סוג וידג׳ט חדש `slareport` ושדות סוגי וידג׳ט *(9 - שירות, 10 - SLA)*.\ [ZBXNEXT-6966](https://support.zabbix.com/browse/ZBXNEXT-6966) נוסף סוג וידג׳ט חדש `item`.\

en-us	# dashboard.create
he	# לוח מחוונים. ליצור

en-us	# dashboard.delete
he	# לוח מחוונים.מחק

en-us	# dashboard.get
he	# dashboard.get

en-us	# > Dashboard object  The following objects are directly related to the `dashboard` API.
he	# > עצם לוח מחוונים  העצמים הבאים קשורים ישירות ל־API‏ `dashboard`.

en-us	### Dashboard page  The dashboard page object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |dashboard\_pageid|string|*(readonly)* ID of the dashboard page.| |name|string|Dashboard page name.<br><br>Default: empty string.| |display\_period|integer|Dashboard page display period (in seconds).<br><br>Possible values: 0, 10, 30, 60, 120, 600, 1800, 3600.<br><br>Default: 0 (will use the default page display period).| |widgets|array|Array of the [dashboard widget](object#dashboard-widget) objects.|
he	### דף לוח המחוונים  לאובייקט עמוד לוח המחוונים יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |dashboard\_pageid|string|*(לקריאה בלבד)* מזהה דף לוח המחוונים.| |name|string|שם דף לוח המחוונים.<br><br>ברירת מחדל: מחרוזת ריקה.| |display\_period|מספר שלם|תקופת הצגת דף לוח המחוונים (בשניות).<br><br>ערכים אפשריים: 0, 10, 30, 60, 120, 600, 1800, 3600.<br><br>ברירת מחדל: 0 (ישתמש בתקופת ברירת המחדל של תצוגת העמוד).| |widgets|מערך|מערך של האובייקטים [יישומון לוח המחוונים](object#dashboard-widget).|

en-us	#### Dashboards  Manage dashboards and make scheduled reports based on them.  [Dashboard API](/manual/api/reference/dashboard) | [Template dashboard API](/manual/api/reference/templatedashboard) | [Report API](/manual/api/reference/report)
he	#### לוחות מחוונים  נהל לוחות מחוונים וערוך דוחות מתוזמנים המבוססים עליהם.  [Dashboard API](/manual/api/reference/dashboard) | [לוח המחוונים של תבניות API](/manual/api/reference/templatedashboard) | [להגיש תלונה API](/manual/api/reference/report)

en-us	### Dashboard  The dashboard object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |dashboardid|string|*(readonly)* ID of the dashboard.| |**name**<br>(required)|string|Name of the dashboard.| |userid|string|Dashboard owner user ID.| |private|integer|Type of dashboard sharing.<br><br>Possible values:<br>0 - public dashboard;<br>1 - *(default)* private dashboard.| |display\_period|integer|Default page display period (in seconds).<br><br>Possible values: 10, 30, 60, 120, 600, 1800, 3600.<br><br>Default: 30.| |auto\_start|integer|Auto start slideshow.<br><br>Possible values:<br>0 - do not auto start slideshow;<br>1 - *(default)* auto start slideshow.|  Note that for some methods (update, delete) the required/optional parameter combination is different.
he	### לוח מחוונים  לאובייקט לוח המחוונים יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |dashboardid|string|*(לקריאה בלבד)* מזהה לוח המחוונים.| |**שם**<br>(חובה)|מחרוזת|שם לוח המחוונים.| |userid|string|זיהוי משתמש של בעל לוח המחוונים.| |private|integer|סוג שיתוף לוח המחוונים.<br><br>ערכים אפשריים:<br>0 - לוח מחוונים ציבורי;<br>1 - *(ברירת מחדל)* לוח מחוונים פרטי.| |display\_period|integer|תקופת ברירת המחדל להצגת דף (בשניות).<br><br>ערכים אפשריים: 10, 30, 60, 120, 600, 1800, 3600.<br><br>ברירת מחדל: 30.| |auto\_start|integer|התחל אוטומטית של מצגת.<br><br>ערכים אפשריים:<br>0 - אל תפעיל אוטומטית מצגת;<br>1 - *(ברירת מחדל)* התחל אוטומטית של מצגת.|  שימו לב שעבור שיטות מסוימות (עדכון, מחק) שילוב הפרמטרים הנדרש/אופציונלי שונה.

en-us	# Dashboard  This class is designed to work with dashboards.  Object references:\  -   [Dashboard](/manual/api/reference/dashboard/object#dashboard) -   [Dashboard     page](/manual/api/reference/dashboard/object#dashboard_page) -   [Dashboard     widget](/manual/api/reference/dashboard/object#dashboard_widget) -   [Dashboard widget     field](/manual/api/reference/dashboard/object#dashboard_widget_field) -   [Dashboard     user](/manual/api/reference/dashboard/object#dashboard_user) -   [Dashboard user     group](/manual/api/reference/dashboard/object#dashboard_user_group)  Available methods:\  -   [dashboard.create](/manual/api/reference/dashboard/create) -     creating new dashboards -   [dashboard.delete](/manual/api/reference/dashboard/delete) -     deleting dashboards -   [dashboard.get](/manual/api/reference/dashboard/get) - retrieving     dashboards -   [dashboard.update](/manual/api/reference/dashboard/update) -     updating dashboards
he	# לוח מחוונים  מחלקה זו תוכננה לעבוד עם לוחות מחוונים.  סימוכין לפריט:\  -   [לוח מחוונים](/manual/api/reference/dashboard/object#dashboard) -   [עמוד לוח     מחוונים](/manual/api/reference/dashboard/object#dashboard_page) -   [וידג׳ט לוח     מחוונים](/manual/api/reference/dashboard/object#dashboard_widget) -   [שדה וידג׳ט לוח     מחוונים](/manual/api/reference/dashboard/object#dashboard_widget_field) -   [משתמש בלוח     מחוונים](/manual/api/reference/dashboard/object#dashboard_user) -   [קבוצת משתמשים בלוח     מחוונים](/manual/api/reference/dashboard/object#dashboard_user_group)  מתודות זמינות:\  -   [dashboard.create](/manual/api/reference/dashboard/create) -     יצירת לוחות מחוונים חדשים -   [dashboard.delete](/manual/api/reference/dashboard/delete) -     מחיקת לוחות מחוונים -   [dashboard.get](/manual/api/reference/dashboard/get) - משיכת     לוחות מחוונים -   [dashboard.update](/manual/api/reference/dashboard/update) -     עדכון לוחות מחוונים

en-us	# dashboard.update
he	# עדכון לוח מחוונים

en-us	### Dashboard user group  List of dashboard permissions based on user groups. It has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**usrgrpid**<br>(required)|string|User group ID.| |**permission**<br>(required)|integer|Type of permission level.<br><br>Possible values:<br>2 - read only;<br>3 - read-write;|
he	### קבוצת משתמשים בלוח המחוונים  רשימת הרשאות לוח המחוונים מבוססת על קבוצות משתמשים. יש לו את הדברים הבאים נכסים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**usrgrpid**<br>(נדרש)|string|מזהה קבוצת משתמשים.| |**הרשאה**<br>(נדרש)|מספר שלם|סוג רמת ההרשאה.<br><br>ערכים אפשריים:<br>2 - לקריאה בלבד;<br>3 - קריאה-כתיבה;|

en-us	### Dashboard user  List of dashboard permissions based on users. It has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**userid**<br>(required)|string|User ID.| |**permission**<br>(required)|integer|Type of permission level.<br><br>Possible values:<br>2 - read only;<br>3 - read-write;|
he	### משתמש בלוח המחוונים  רשימת הרשאות לוח המחוונים מבוססת על משתמשים. יש לו את הדברים הבאים נכסים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**userid**<br>(נדרש)|string|מזהה משתמש.| |**הרשאה**<br>(נדרש)|מספר שלם|סוג רמת ההרשאה.<br><br>ערכים אפשריים:<br>2 - לקריאה בלבד;<br>3 - קריאה-כתיבה;|

en-us	### Dashboard widget field  The dashboard widget field object has the following properties.  |Property|[Type](/manual/api/reference_commentary#data_types)|Description| |--|--|------| |**type**<br>(required)|integer|Type of the widget field.<br><br>Possible values:<br>0 - Integer;<br>1 - String;<br>2 - Host group;<br>3 - Host;<br>4 - Item;<br>5 - Item prototype;<br>6 - Graph;<br>7 - Graph prototype;<br>8 - Map;<br>9 - Service;<br>10 - SLA.| |**name**<br>(required)|string|Widget field name.<br><br>Possible values: see [Dashboard widget fields](/manual/api/reference/dashboard/widget_fields).| |**value**<br>(required)|mixed|Widget field value depending on the type.<br><br>Possible values: see [Dashboard widget fields](/manual/api/reference/dashboard/widget_fields).|
he	### שדה הווידג'ט של לוח המחוונים  לאובייקט שדה הווידג'ט של לוח המחוונים יש את המאפיינים הבאים.  |Property|[Type](/manual/api/reference_commentary#data_types)|תיאור| |--|--|------| |**סוג**<br>(נדרש)|מספר שלם|סוג שדה הווידג'ט.<br><br>ערכים אפשריים:<br>0 - מספר שלם;<br>1 - מחרוזת;<br>2 - מארח group;<br>3 - מארח;<br>4 - פריט;<br>5 - אב טיפוס של פריט;<br>6 - גרף;<br>7 - אב טיפוס גרף;<br>8 - מפה;<br>9 - שירות;<br>10 - SLA.| |**שם**<br>(חובה)|מחרוזת|שם שדה ווידג'ט.<br><br>ערכים אפשריים: ראה [שדות יישומון של לוח מחוונים](/manual/api/reference/dashboard/widget_fields).| |**ערך**<br>(נדרש)|מעורב|ערך שדה ווידג'ט בהתאם לסוג.<br><br>ערכים אפשריים: ראה [שדות יישומון של לוח מחוונים](/manual/api/reference/dashboard/widget_fields) .|

en-us	#### Database engine  This is probably the most important part of Zabbix tuning. Zabbix heavily depends on the availability and performance of database engine.  -   use fastest database engine, i.e. MySQL or PostgreSQL -   use stable release of a database engine -   rebuild MySQL or PostgreSQL from sources to get maximum performance -   follow performance tuning instructions taken from MySQL or     PostgreSQL documentation -   for MySQL, use InnoDB table structure -   ZABBIX works at least 1.5 times faster (comparing to MyISAM) if     InnoDB is used. This is because of increased parallelism. However,     InnoDB requires more CPU power. -   tuning the database server for the best performance is highly     recommended. -   keep database tables on different hard disks -   'history', 'history\_str, 'items' 'functions', triggers', and     'trends' are most heavily used tables. -   for large installations keeping MySQL temporary files in tmpfs is:     -   MySQL >= 5.5: not recommended ([MySQL bug         \#58421](https://bugs.mysql.com/bug.php?id=58421))     -   MySQL < 5.5: recommended
he	#### מנוע מסד נתונים  זה כנראה החלק החשוב ביותר של כוונון Zabbix. זאביקס תלוי מאוד בזמינות ובביצועים של מנוע מסד הנתונים.  - השתמש במנוע מסד הנתונים המהיר ביותר, כלומר MySQL או PostgreSQL - השתמש במהדורה יציבה של מנוע מסד נתונים - בנה מחדש את MySQL או PostgreSQL ממקורות כדי לקבל ביצועים מקסימליים - עקוב אחר הוראות כוונון ביצועים שנלקחו מ-MySQL או      תיעוד PostgreSQL - עבור MySQL, השתמש במבנה הטבלה InnoDB - ZABBIX עובד לפחות פי 1.5 מהר יותר (בהשוואה ל-MyISAM) אם      נעשה שימוש ב-InnoDB. הסיבה לכך היא מקביליות מוגברת. למרות זאת,      InnoDB דורש יותר כוח מעבד. - כוונון שרת מסד הנתונים לביצועים הטובים ביותר הוא גבוה      מוּמלָץ. - שמור טבלאות מסד נתונים על דיסקים קשיחים שונים - 'history', 'history\_str, 'items' 'functions', triggers, וכן      'טרנדים' הם הטבלאות הנפוצות ביותר. - עבור התקנות גדולות שמירה על קבצי MySQL זמניים ב-tmpfs היא:      - MySQL >= 5.5: לא מומלץ ([באג MySQL          \#58421](https://bugs.mysql.com/bug.php?id=58421))      - MySQL < 5.5: מומלץ