---
sourceDocument: Yokohama Erstellen oder ändern Sie Anwendungen
sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/de-DE/yokohama/application-development

 Release :

    - yokohama

ft:locale :

    - de-DE

ft:publication_title :

    - Yokohama Erstellen oder ändern Sie Anwendungen

ft:clusterId :

    - cadev

bundleId :

    - cadev

workflow :

    - Creator


---

Erstellen Sie einen anwenderdefinierten Befehl in ServiceNow CLI
================================================================

Erstellen Sie einen anwenderdefinierten Befehl in ServiceNow CLI {#ariaid-title1}
=================================================================================

* Freigeben Version: Yokohama
* 
* Aktualisiert 30. Januar 2025
* 
* ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 6 Minuten Lesedauer

Verwalten Sie Ihre anwenderdefinierte Anwendung über die Befehlszeile, indem Sie anwenderdefinierte Befehle in ServiceNow CLIerstellen.

Vorbereitungen
--------------

Erforderliche Rolle: Administrator

Warum und wann dieser Vorgang ausgeführt wird
---------------------------------------------

Der Befehl ServiceNow CLI wird einem geskripteten REST-Endpunkt in der Endpunkttabelle \[sn_cli_metadata_end_point\] zugeordnet. Sie können einen geskripteten REST-Endpunkt definieren, um eine Funktion in Ihrer anwenderdefinierten Anwendung auszuführen, oder einen beliebigen vorhandenen REST-Endpunkt verwenden. Ordnen Sie dann einen CLI-Befehl zu, um den REST-Aufruf auszuführen.

Prozedur
--------

1. Machen Sie einen REST-Endpunkt für einen ServiceNow CLI -Befehl verfügbar.
   1. Navigieren zu Befehlszeilenschnittstelle (CLI)Endpunkte.
   2. Wählen Sie Neu aus, und füllen Sie das Formular aus.  
      {#create-command__table_lfj_mbj_n4b__entry__2}

      |      Feld      |                                                                                                                                                                                                                                                                                 Beschreibung                                                                                                                                                                                                                                                                                 |
      |----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      | Ressourcenpfad | Erforderlich. Pfad zum Endpunkt in der Instanz, dem ein Befehl zugeordnet werden soll. Kann der Pfad zu einer eingehenden REST API oder einer geskripteten REST API sein. Beispiel: `api/now/table/{table}/{sysid}`. Weitere Informationen finden Sie [unter Verfügbare REST APIs](https://www.servicenow.com/docs/access?context=api-rest&version=yokohama&pubname=yokohama-api-reference&ft:locale=en-US) und [Geskriptete REST APIs](https://www.servicenow.com/docs/access?context=c_CustomWebServices&version=yokohama&pubname=yokohama-api-reference&ft:locale=en-US). |
      | HTTP-Methode   | Erforderlich. Zu verwendende HTTP-Methode, wenn der Benutzer den zugehörigen Befehl ausführt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
      | Anwendung      | Schreibgeschützter Anwendungsbereich für den Endpunkt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      [ ]

      {#create-command__table_lfj_mbj_n4b}
   {#create-command__substeps_hs4_mw3_n4b}
2. **Wahlweise:** Erstellen Sie eine Befehlsgruppe.  
   Alternativ können Sie Ihren neuen Befehl einer vorhandenen Befehlsgruppe hinzufügen.
   1. Navigieren zu Befehlszeilenschnittstelle (CLI)Befehlsgruppen.
   2. Wählen Sie Neu aus, und füllen Sie das Formular aus.  
      {#create-command__table_tyy_gdj_n4b__entry__2}

      |         Feld         |                                                                                                                                                                                                              Beschreibung                                                                                                                                                                                                               |
      |----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      | Name                 | Erforderlich. Name der Befehlsgruppe.                                                                                                                                                                                                                                                                                                                                                                                                   |
      | Übergeordnete Gruppe | Übergeordnete Befehlsgruppe.                                                                                                                                                                                                                                                                                                                                                                                                            |
      | Referenzgruppe       | Zu referenzierende Befehlsgruppe. Sie können beispielsweise eine neue Befehlsgruppe als Alias für eine vorhandene Befehlsgruppe erstellen. Wenn der Benutzer einen referenzierten Befehl mit der neuen Befehlsgruppe aufruft, wird der ursprüngliche Befehl ausgeführt. Auf diese Weise können Sie eine für Ihre anwenderdefinierte Anwendung spezifische Befehlsgruppe erstellen, die sowohl neue als auch vorhandene Befehle enthält. |
      | Kurzbeschreibung     | Erforderlich. Kurzbeschreibung für die Befehlsgruppe.                                                                                                                                                                                                                                                                                                                                                                                   |
      | Beschreibung         | Beschreibung der Befehlsgruppe, die als Hilfetext verwendet wird, wenn der Benutzer den Befehl `„--help"` für die Befehlsgruppe ausführt.                                                                                                                                                                                                                                                                                               |
      | Anwendung            | Schreibgeschützter Anwendungsbereich für die Befehlsgruppe.                                                                                                                                                                                                                                                                                                                                                                             |
      | Aktiv                | Wenn diese Option ausgewählt ist, ist die Befehlsgruppe aktiv.                                                                                                                                                                                                                                                                                                                                                                          |
      [ ]

      {#create-command__table_tyy_gdj_n4b}
   {#create-command__substeps_o3t_qbj_n4b}
3. Erstellen Sie einen Befehl.
   1. Navigieren zu Befehlszeilenschnittstelle (CLI)Befehle.
   2. Wählen Sie Neu aus, und füllen Sie das Formular aus.  
      {#create-command__table_o3q_qyg_m4b__entry__2}

      |        Feld         |                                                                                                                                                                                                                                                                         Beschreibung                                                                                                                                                                                                                                                                          |
      |---------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      | Name                | Erforderlich. Name des Befehls                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
      | Befehlsgruppe       | Erforderlich. Befehlsgruppe, zu der der Befehl gehört.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
      | Referenzbefehl      | Zu referenzierender Befehl. Sie können beispielsweise einen neuen Befehl als Alias für einen vorhandenen Befehl erstellen. Wenn der Benutzer den neuen Befehl aufruft, wird der ursprüngliche Befehl ausgeführt. Auf diese Weise können Sie einen für Ihre anwenderdefinierte Anwendung spezifischen Befehl erstellen, der vorhandene Funktionen ausführt. Hinweis: Ein Befehl kann nicht auf einen Befehl verweisen, der auf einen anderen Befehl verweist, oder auf einen untergeordneten Befehl, einen Vorgängerbefehl oder einen Rückrufbefehl verweisen. |
      | API-Endpunkt        | Erforderlich. API-Aufruf, der ausgeführt werden soll, wenn der Anwender den Befehl ausführt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
      | Kurzbeschreibung    | Erforderlich. Kurze Beschreibung des Befehls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
      | Anwendung           | Schreibgeschützter Anwendungsbereich für den Befehl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
      | Aktiv               | Wenn diese Option ausgewählt ist, ist der Befehl aktiv.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      | Ist Rückrufbefehl   | Bei „wahr" wird der Befehl als Rückrufbefehl festgelegt. Wählen Sie diese Option aus, um den Befehl auf dem CLI-Client auszublenden und zu verhindern, dass Benutzer ihn über die Befehlszeile aufrufen können. Verwenden Sie dieses Feld mit dem Abschnitt „Rückruf" eines primären Befehls. Der Rückrufbefehl wird ausgeführt, wenn der primäre Befehl abgeschlossen ist.                                                                                                                                                                                   |
      | Hilfetext                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ||
      | Beschreibung        | Beschreibung des Befehls, der als Hilfetext verwendet wird, wenn der Anwender den Befehl `„--help"` ausführt.                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
      | Beispiele           | Beispiele für den Befehl, die als Hilfetext verwendet werden, wenn der Anwender den Befehl `„--help"` ausführt.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
      | Ausdrücke                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ||
      | Erfolgsausdruck     | Ausdruck, der verwendet wird, um die Antwort vom Server auszuwerten und zu bestimmen, ob der Befehl erfolgreich war. Beispiel: `result.code = 1`.                                                                                                                                                                                                                                                                                                                                                                                                             |
      | Fehlerausdruck      | Ausdruck, der verwendet wird, um die Antwort vom Server auszuwerten und zu bestimmen, ob der Befehl fehlgeschlagen ist.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      | Nachrichten                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ||
      | Erfolgsmeldung      | Meldung, die auf dem CLI-Client angezeigt wird, wenn der Befehl erfolgreich ist.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
      | Fortschrittsmeldung | Meldung, die auf dem CLI-Client angezeigt wird, wenn der Befehl ausgeführt wird.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
      | Fehlermeldung       | Nachricht, die auf dem CLI-Client angezeigt wird, wenn der Befehl fehlschlägt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
      | Rückruf                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ||
      | Rückrufausdruck     | Ausdruck, mit dem bestimmt wird, ob der Rückrufbefehl ausgeführt werden soll. Sie können beispielsweise einen Ausdruck schreiben, der einen Prozess mit langer Laufzeit überprüft. Wenn der Ausdruck ein bestimmtes Ergebnis erzeugt, wird der Rückruf ausgeführt.                                                                                                                                                                                                                                                                                            |
      | Rückrufbefehl       | Befehl, der ausgeführt werden soll, wenn der Rückrufausdruck erfüllt ist. Muss ein Befehl sein, bei dem das Feld „Ist Rückrufbefehl" ausgewählt ist.                                                                                                                                                                                                                                                                                                                                                                                                          |
      | Rückrufintervall    | Das Intervall zwischen den Ausführungen des Rückrufbefehls. Einheit: Millisekunden Standard: 1.000                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      | Max. Wiederholungen | Maximale Anzahl von Ausführungen des Rückrufbefehls. Standard: 10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
      [ ]

      {#create-command__table_o3q_qyg_m4b}
   3. Erstellen Sie in den zugehörigen Listen „Befehlsargumente" alle Befehlsargumente, die für den Befehl erforderlich sind.  
      Erstellen Sie ein Befehlsargument, damit Anwender beim Ausführen eines Befehls Optionen festlegen können.
      {#create-command__table_hg5_nnh_m4b__entry__2}

      |             Feld             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
      |------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      | Name                         | Erforderlich. Name des Befehlsarguments, z. B. `data`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
      | Kurzer Name                  | Kurzbezeichnung des Befehlsarguments, z. ` B. d`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
      | Datentyp                     | Erforderlich. Typ der Daten, die für das Befehlsargument erwartet werden. Verfügbare Optionen: * Zeichenfolge: Ermöglicht Anwendern die Eingabe einer Zeichenfolge als Eingabe. * Ganzzahl: Ermöglicht Anwendern die Eingabe einer Zahl. * Boolescher Wert: Ermöglicht Anwendern die Eingabe von `„wahr"` oder `„falsch"`. * Dateieingabe: Ermöglicht Anwendern das Hochladen einer Datei als Eingabe. Ordnen Sie dieses Argument im nächsten Schritt einem Parametertyp „ Body" in der zugehörigen Liste „API-Endpunktargumente" zu. Benutzer können Nur-Text, YAML, JSON oder einen anderen von der REST-API akzeptierten Dateityp übergeben. Wenn der Benutzer eine YAML-Datei übermittelt, konvertiert der CLI-Client standardmäßig eine Datei im JSON-Format. Verwenden Sie das Feld Vorverarbeitung überspringen, um dieses Verhalten zu deaktivieren. * Passwort: Ermöglicht Anwendern die sichere Eingabe eines Passworts als Eingabe. {#create-command__ul_uxr_q1w_y4b} Hinweis: Für die Datentypen „Dateieingabe" beträgt die Dateigrößenbeschränkung standardmäßig 10 MB. Sie können diesen Grenzwert jedoch mit der Systemeigenschaft glide.rest.scripted.max_inbound_content_length_mb ändern. |
      | Vorverarbeitung überspringen | Legen Sie diese Kennzeichnung fest, um zu verhindern, dass der CLI-Client YAML-Dateien in das JSON-Format konvertiert, bevor er sie in der Anforderung sendet. Wenn der Datentyp auf Dateieingabe festgelegt ist und der Benutzer eine YAML-Datei übermittelt, konvertiert der CLI-Client die Datei in JSON, bevor der Befehl standardmäßig ausgeführt wird. Hinweis: Gilt nur, wenn der Datentyp auf Dateieingabefestgelegt ist.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
      | Standardwert                 | Zu verwendender Standardwert, wenn der Anwender keinen Wert übergibt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
      | Kurzbeschreibung             | Erforderlich. Kurze Beschreibung des Befehlsarguments. Wird als Hilfetext verwendet, wenn der Anwender den Befehl `„--help"` ausführt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
      | Anwendung                    | Schreibgeschützter Anwendungsbereich für das Argument.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
      | Befehl                       | Erforderlich. Befehl, für den dieses Argument gilt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
      | Obligatorisch                | Wenn diese Option ausgewählt ist, muss der Anwender beim Ausführen des zugehörigen Befehls einen Wert für das Argument angeben.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
      | Aufforderung                 | Aufforderung, Informationen vom Anwender anzufordern. Die CLI fragt nach Informationen, wenn der Benutzer ein erforderliches Argument nicht in einen Befehl einfügt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
      | Sichtbarkeitsausdruck        | Ausdruck, mit dem bestimmt wird, ob die CLI zur Eingabe des Arguments auffordert. Wird normalerweise verwendet, um ein Argument basierend auf dem Wert anzuzeigen, der einem vorherigen Argument bereitgestellt wurde.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
      | Reihenfolge                  | Reihenfolge, in der zur Eingabe des Arguments aufgefordert wird.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
      [ ]

      {#create-command__table_hg5_nnh_m4b}
   4. Erstellen Sie in den zugehörigen Listen API-Endpunktargumente die API-Endpunktargumente, die für den Befehl erforderlich sind.  
      Ordnen Sie Befehlsargumente aus der zugehörigen Liste „Befehlsargumente" Parametern in Ihrem REST-Endpunkt zu.
      {#create-command__table_jqf_qnh_m4b__entry__2}

      |     Feld     |                                                                                                                                                Beschreibung                                                                                                                                                 |
      |--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      | Name         | Erforderlich. Name des Arguments.                                                                                                                                                                                                                                                                           |
      | Wert         | Erforderlich. Der Wert aus dem Befehl, den Sie an den REST-Endpunkt übergeben möchten. Sie können einen statischen Wert oder einen Ausdruck wie `{flags.table}`übergeben. Verwenden Sie die globale Variable `„kennzeichnet"`, um auf die Befehlsargumente zuzugreifen.                                     |
      | Parametertyp | Erforderlich. Der Typ des Parameters im REST-Endpunkt, an den Sie den Wert übergeben möchten. Wenn Sie beispielsweise Textkörperauswählen, übergibt die CLI den Wert des Felds Wert an den REST-Endpunkttext. Verfügbare Optionen: * Textkörper * Header * Pfad * Abfrage {#create-command__ul_xpw_d3c_n4b} |
      | Anwendung    | Schreibgeschützter Anwendungsbereich für das Argument.                                                                                                                                                                                                                                                      |
      | Befehl       | Erforderlich. Befehl, für den dieses Argument gilt.                                                                                                                                                                                                                                                         |
      [ ]

      {#create-command__table_jqf_qnh_m4b}
   5. Erstellen Sie in den zugehörigen Listen „Rückgabewerte" die Rückgabewerte, die für den Befehl erforderlich sind.  
      Erstellen Sie Rückgabewerte, um nur bestimmte Schlüssel aus der Antwort zurückzugeben.
      {#create-command__table_b13_qnh_m4b__entry__2}

      |     Feld     |                                         Beschreibung                                          |
      |--------------|-----------------------------------------------------------------------------------------------|
      | Pfadausdruck | Erforderlich. Ausdruck, der den Pfad zu dem Schlüssel darstellt, den Sie zurückgeben möchten. |
      | Alias        | Variablenname, dem der Rückgabewert zugewiesen werden soll.                                   |
      | Anwendung    | Schreibgeschützter Anwendungsbereich für den Befehl.                                          |
      | Befehl       | Erforderlich. Befehl, für den der Rückgabewert gilt.                                          |
      [ ]

      {#create-command__table_b13_qnh_m4b}
   {#create-command__substeps_hnv_pyg_m4b}

Ergebnisse
----------

Wenn der Benutzer den Befehl ServiceNow CLI ausführt, führt das System den zugehörigen REST-API-Aufruf aus und gibt das Ergebnis an ServiceNow CLIzurück.

