

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Greengrass-Befehlszeilenschnittstelle
<a name="gg-cli"></a>

Mit der Greengrass-Befehlszeilenschnittstelle (CLI) können Sie mit AWS IoT Greengrass Core auf Ihrem Gerät interagieren, um Komponenten lokal zu entwickeln und Probleme zu debuggen. Sie können beispielsweise die Greengrass-CLI verwenden, um eine lokale Bereitstellung zu erstellen und eine Komponente auf dem Kerngerät neu zu starten. 

Stellen Sie die [Greengrass-CLI-Komponente](greengrass-cli-component.md) (`aws.greengrass.Cli`) bereit, um die Greengrass-CLI auf Ihrem Kerngerät zu installieren.

**Wichtig**  
 <a name="local-dev-tools-production-environment-warning"></a>Wir empfehlen, diese Komponente nur in Entwicklungsumgebungen zu verwenden, nicht in Produktionsumgebungen. Diese Komponente bietet Zugriff auf Informationen und Operationen, die Sie in einer Produktionsumgebung normalerweise nicht benötigen. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie diese Komponente nur dort einsetzen, wo Sie sie benötigen. 

**Topics**
+ [Installieren Sie die Greengrass-CLI](install-gg-cli.md)
+ [Greengrass-CLI-Befehle](gg-cli-reference.md)

# Installieren Sie die Greengrass-CLI
<a name="install-gg-cli"></a>

Sie können die Greengrass-CLI auf eine der folgenden Arten installieren: 
+ Verwenden Sie das `--deploy-dev-tools` Argument, wenn Sie die AWS IoT Greengrass Core-Software zum ersten Mal auf Ihrem Gerät einrichten. Sie müssen auch angeben`--provision true`, ob dieses Argument angewendet werden soll.
+ Stellen Sie die Greengrass CLI-Komponente (`aws.greengrass.Cli`) auf Ihrem Gerät bereit.

In diesem Abschnitt werden die Schritte zur Bereitstellung der Greengrass-CLI-Komponente beschrieben. Hinweise zur Installation der Greengrass-CLI bei der Ersteinrichtung finden Sie unter[Tutorial: Erste Schritte mit AWS IoT Greengrass V2](getting-started.md).

## Voraussetzungen
<a name="gg-cli-prereqs"></a>

Um die Greengrass CLI-Komponente bereitzustellen, müssen Sie die folgenden Anforderungen erfüllen:
+ AWS IoT Greengrass Kernsoftware, die auf Ihrem Kerngerät installiert und konfiguriert ist. Weitere Informationen finden Sie unter [Tutorial: Erste Schritte mit AWS IoT Greengrass V2](getting-started.md). 
+  AWS CLI Um die Greengrass-CLI bereitzustellen, müssen Sie die AWS CLI installiert und konfiguriert haben. Weitere Informationen finden Sie unter [Konfigurieren der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) im *AWS Command Line Interface -Leitfaden*.
+ <a name="greengrass-cli-authorization-requirement"></a>Sie müssen autorisiert sein, die Greengrass-CLI zu verwenden, um mit der AWS IoT Greengrass Core-Software zu interagieren. Führen Sie einen der folgenden Schritte aus, um die Greengrass-CLI zu verwenden:
  + Verwenden Sie den Systembenutzer, der die AWS IoT Greengrass Core-Software ausführt.
  + Verwenden Sie einen Benutzer mit Root- oder Administratorrechten. Auf Linux-Core-Geräten können Sie diese Option verwenden, um `sudo` Root-Rechte zu erhalten.
  + Verwenden Sie einen Systembenutzer, der zu einer Gruppe gehört, die Sie bei der Bereitstellung der Komponente in den `AuthorizedWindowsGroups` Konfigurationsparametern `AuthorizedPosixGroups` oder angeben. Weitere Informationen finden Sie unter [Konfiguration der Greengrass-CLI-Komponente](greengrass-cli-component.md#greengrass-cli-component-configuration).

## Stellen Sie die Greengrass-CLI-Komponente bereit
<a name="gg-cli-deploy"></a>

Gehen Sie wie folgt vor, um die Greengrass CLI-Komponente auf Ihrem Kerngerät bereitzustellen:

### Um die Greengrass CLI-Komponente (Konsole) bereitzustellen
<a name="gg-cli-deploy-console"></a>

1. Melden Sie sich bei der [AWS IoT Greengrass -Konsole](https://console.aws.amazon.com/greengrass) an.

1. Wählen Sie im Navigationsmenü **Komponenten**.

1. Wählen Sie auf der Seite **Komponenten** auf der Registerkarte **Öffentliche Komponenten** die Option `aws.greengrass.Cli` aus.

1. Wählen Sie auf der **aws.greengrass.Cli** Seite **Bereitstellen** aus.

1. Wählen **Sie unter Zur Bereitstellung hinzufügen** die Option **Neue Bereitstellung erstellen** aus.

1. Wählen Sie auf der Seite **Ziel angeben** unter **Bereitstellungsziele** in der Liste **Zielname** die Greengrass-Gruppe aus, für die Sie die Bereitstellung durchführen möchten, und klicken Sie auf **Weiter**.

1. Vergewissern **Sie sich auf der Seite „Komponenten auswählen**“, dass die **aws.greengrass.Cli**Komponente ausgewählt ist, und klicken Sie auf **Weiter**.

1. Behalten Sie auf der Seite **Komponenten konfigurieren** die Standardkonfigurationseinstellungen bei und wählen Sie **Weiter**.

1. Behalten Sie auf der Seite **Erweiterte Einstellungen konfigurieren** die Standardkonfigurationseinstellungen bei und wählen Sie **Weiter**.

1. Klicken Sie auf der Seite „**Überprüfen**“ auf **Bereitstellen**

### So stellen Sie die Greengrass-CLI-Komponente bereit ()AWS CLI
<a name="gg-cli-deploy-cli"></a>

1. Erstellen Sie auf Ihrem Gerät eine `deployment.json` Datei, um die Bereitstellungskonfiguration für die Greengrass CLI-Komponente zu definieren. Diese Datei sollte wie folgt aussehen:

   ```
   {
     "targetArn":"targetArn",
     "components": {
       "aws.greengrass.Cli": {
         "componentVersion": "2.16.1",
         "configurationUpdate": {
           "merge": "{\"AuthorizedPosixGroups\":\"<group1>,<group2>,...,<groupN>\",\"AuthorizedWindowsGroups\":\"<group1>,<group2>,...,<groupN>\"}"
         }
       }
     }
   }
   ```
   + Ersetzen Sie im `target` Feld `targetArn` durch den Amazon-Ressourcennamen (ARN) des Objekts oder der Objektgruppe, auf die die Bereitstellung ausgerichtet werden soll, und zwar im folgenden Format: 
     + Objekt: `arn:aws:iot:region:account-id:thing/thingName`
     + Objektgruppe: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
   + Geben Sie im `aws.greengrass.Cli` Komponentenobjekt die Werte wie folgt an:  
`version`  
Die Version der Greengrass-CLI-Komponente.  
`configurationUpdate.AuthorizedPosixGroups`  
(Optional) Eine Zeichenfolge, die eine durch Kommas getrennte Liste von Systemgruppen enthält. Sie autorisieren diese Systemgruppen, die Greengrass-CLI für die Interaktion mit der AWS IoT Greengrass Core-Software zu verwenden. Sie können Gruppennamen oder Gruppen angeben. IDs `group1,1002,group3`Autorisiert beispielsweise drei Systemgruppen (`group1`, und`group3`)`1002`, die Greengrass-CLI zu verwenden.  
Wenn Sie keine zu autorisierenden Gruppen angeben, können Sie die Greengrass-CLI als Root-Benutzer (`sudo`) oder als Systembenutzer verwenden, der die AWS IoT Greengrass Core-Software ausführt.  
`configurationUpdate.AuthorizedWindowsGroups`  
(Optional) Eine Zeichenfolge, die eine durch Kommas getrennte Liste von Systemgruppen enthält. Sie autorisieren diese Systemgruppen, die Greengrass-CLI für die Interaktion mit der AWS IoT Greengrass Core-Software zu verwenden. Sie können Gruppennamen oder Gruppen angeben. IDs `group1,1002,group3`Autorisiert beispielsweise drei Systemgruppen (`group1`, und`group3`)`1002`, die Greengrass-CLI zu verwenden.  
Wenn Sie keine zu autorisierenden Gruppen angeben, können Sie die Greengrass-CLI als Administrator oder als Systembenutzer verwenden, der die AWS IoT Greengrass Core-Software ausführt.

1. Führen Sie den folgenden Befehl aus, um die Greengrass-CLI-Komponente auf dem Gerät bereitzustellen:

   ```
   $ aws greengrassv2 create-deployment --cli-input-json file://path/to/deployment.json
   ```

Während der Installation fügt die Komponente einen symbolischen Link zu `greengrass-cli` dem `/greengrass/v2/bin` Ordner auf Ihrem Gerät hinzu, und Sie führen die Greengrass-CLI von diesem Pfad aus aus. Um die Greengrass-CLI ohne ihren absoluten Pfad auszuführen, fügen Sie Ihren `/greengrass/v2/bin` Ordner zu Ihrer PATH-Variablen hinzu. Führen Sie den folgenden Befehl aus, um die Greengrass CLI-Installation zu überprüfen:

------
#### [ Linux or Unix ]

```
/greengrass/v2/bin/greengrass-cli help
```

------
#### [ Windows ]

```
C:\greengrass\v2\bin\greengrass-cli help
```

------

Die Ausgabe sollte folgendermaßen aussehen:

```
Usage: greengrass-cli [-hV] [--ggcRootPath=<ggcRootPath>] [COMMAND]
Greengrass command line interface

      --ggcRootPath=<ggcRootPath>
                  The AWS IoT Greengrass V2 root directory.
  -h, --help      Show this help message and exit.
  -V, --version   Print version information and exit.
Commands:
  help                Show help information for a command.
  component           Retrieve component information and stop or restart
                        components.
  deployment          Create local deployments and retrieve deployment status.
  logs                Analyze Greengrass logs.
  get-debug-password  Generate a password for use with the HTTP debug view
                        component.
```

Wenn das `greengrass-cli` nicht gefunden wird, konnte die Greengrass-CLI bei der Bereitstellung möglicherweise nicht installiert werden. Weitere Informationen finden Sie unter [Problembehebung AWS IoT Greengrass V2](troubleshooting.md).

# Greengrass-CLI-Befehle
<a name="gg-cli-reference"></a>

Die Greengrass-CLI bietet eine Befehlszeilenschnittstelle für die lokale Interaktion mit Ihrem AWS IoT Greengrass Kerngerät. Greengrass-CLI-Befehle verwenden das folgende Format.

```
$ greengrass-cli <command> <subcommand> [arguments]
```

Standardmäßig interagiert die `greengrass-cli` ausführbare Datei im `/greengrass/v2/bin/` Ordner mit der Version der AWS IoT Greengrass Core-Software, die `/greengrass/v2` im Ordner ausgeführt wird. Wenn Sie eine ausführbare Datei aufrufen, die sich nicht an diesem Speicherort befindet, oder wenn Sie mit der AWS IoT Greengrass Core-Software an einem anderen Speicherort interagieren möchten, müssen Sie eine der folgenden Methoden verwenden, um den Stammpfad der AWS IoT Greengrass Core-Software, mit der Sie interagieren möchten, explizit anzugeben:<a name="greengrass-cli-set-root-path"></a>
+ Legen Sie die Umgebungsvariable `GGC_ROOT_PATH` auf `/greengrass/v2` fest.
+ Fügen Sie das `--ggcRootPath /greengrass/v2` Argument zu Ihrem Befehl hinzu, wie im folgenden Beispiel gezeigt.

  ```
  greengrass-cli --ggcRootPath /greengrass/v2 <command> <subcommand> [arguments]
  ```

Sie können die folgenden Argumente mit jedem Befehl verwenden:
+ Wird `--help` für Informationen über einen bestimmten Greengrass-CLI-Befehl verwendet. 
+ Wird `--version` für Informationen über die Greengrass-CLI-Version verwendet.

In diesem Abschnitt werden die Greengrass-CLI-Befehle beschrieben und Beispiele für diese Befehle bereitgestellt. Die Zusammenfassung für jeden Befehl zeigt seine Argumente und ihre Verwendung. Optionale Argumente werden in eckigen Klammern angezeigt.

**Topics**
+ [Komponente](gg-cli-component.md)
+ [Bereitstellung](gg-cli-deployment.md)
+ [Protokolle](gg-cli-logs.md)
+ [get-debug-password](gg-cli-get-debug-password.md)

# Komponente
<a name="gg-cli-component"></a>

Verwenden Sie den `component` Befehl, um mit lokalen Komponenten auf Ihrem Kerngerät zu interagieren. 

**Unterbefehle**
+ [Details](#component-details)
+ [auflisten](#component-list)
+ [Neustart](#component-restart)
+ [stop](#component-stop)

## Details
<a name="component-details"></a>

Rufen Sie die Version, den Status und die Konfiguration einer Komponente ab. 

**Syntax**  

```
greengrass-cli component details --name <component-name> 
```

**Argumente**  
`--name`,`-n`. Der Name der Komponente.

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die erzeugt wird, wenn Sie diesen Befehl ausführen.  

```
$ sudo greengrass-cli component details --name MyComponent 

Component Name: MyComponent 
Version: 1.0.0
State: RUNNING
Configuration: null
```

## auflisten
<a name="component-list"></a>

Rufen Sie den Namen, die Version, den Status und die Konfiguration aller auf dem Gerät installierten Komponenten ab.

**Syntax**  

```
greengrass-cli component list
```

**Argumente**  
Keine

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die erzeugt wird, wenn Sie diesen Befehl ausführen.  

```
$ sudo greengrass-cli component list

Components currently running in Greengrass:
Component Name: FleetStatusService
Version: 0.0.0
State: RUNNING
Configuration: {"periodicUpdateIntervalSec":86400.0}
Component Name: UpdateSystemPolicyService
Version: 0.0.0
State: RUNNING
Configuration: null
Component Name: aws.greengrass.Nucleus
Version: 2.0.0
State: FINISHED
Configuration: {"awsRegion":"region","runWithDefault":{"posixUser":"ggc_user:ggc_group"},"telemetry":{}}
Component Name: DeploymentService
Version: 0.0.0
State: RUNNING
Configuration: null
Component Name: TelemetryAgent
Version: 0.0.0
State: RUNNING
Configuration: null
Component Name: aws.greengrass.Cli
Version: 2.0.0
State: RUNNING
Configuration: {"AuthorizedPosixGroups":"ggc_user"}
```

## Neustart
<a name="component-restart"></a>

Starten Sie die Komponenten neu.

**Syntax**  

```
greengrass-cli component restart --names <component-name>,...
```

**Argumente**  
`--names`,`-n`. Der Name der Komponente. Es ist mindestens ein Komponentenname erforderlich. Sie können zusätzliche Komponentennamen angeben, indem Sie die einzelnen Namen durch ein Komma trennen.

**Ausgabe**  
Keine

## stop
<a name="component-stop"></a>

Beenden Sie die Ausführung von Komponenten. 

**Syntax**  

```
greengrass-cli component stop --names <component-name>,...
```

**Argumente**  
`--names`,`-n`. Der Name der Komponente. Es ist mindestens ein Komponentenname erforderlich. Sie können bei Bedarf weitere Komponentennamen angeben, wobei Sie die einzelnen Namen durch ein Komma trennen.

**Ausgabe**  
Keine

# Bereitstellung
<a name="gg-cli-deployment"></a>

Verwenden Sie den `deployment` Befehl, um mit lokalen Komponenten auf Ihrem Kerngerät zu interagieren. 

Verwenden Sie den `status` Unterbefehl, um den Fortschritt einer lokalen Bereitstellung zu überwachen. Sie können den Fortschritt einer lokalen Bereitstellung nicht mit der Konsole überwachen.

**Unterbefehle**
+ [create](#deployment-create)
+ [abbrechen](#deployment-cancel)
+ [auflisten](#deployment-list)
+ [Status](#deployment-status)

## create
<a name="deployment-create"></a>

Erstellen oder aktualisieren Sie eine lokale Bereitstellung mithilfe bestimmter Komponentenrezepte, Artefakte und Laufzeitargumente.

**Syntax**  

```
greengrass-cli deployment create 
    --recipeDir path/to/component/recipe
    [--artifactDir path/to/artifact/folder ]
    [--update-config {component-configuration}]
    [--groupId <thing-group>]
    [--merge "<component-name>=<component-version>"]...
    [--runWith "<component-name>:posixUser=<user-name>[:<group-name>]"]...
    [--systemLimits "{component-system-resource-limits}]"]...
    [--remove <component-name>,...]
    [--failure-handling-policy <policy name[ROLLBACK, DO_NOTHING]>]
```

**Argumente**  
+ `--recipeDir`,`-r`. Der vollständige Pfad zu dem Ordner, der die Rezeptdateien der Komponenten enthält.
+ `--artifactDir`,`-a`. Der vollständige Pfad zu dem Ordner, der die Artefaktdateien enthält, die Sie in Ihre Bereitstellung aufnehmen möchten. Der Ordner artefacts muss die folgende Verzeichnisstruktur enthalten:

  ```
  /path/to/artifact/folder/<component-name>/<component-version>/<artifacts>
  ```
+ `--update-config`,`-c`. Die Konfigurationsargumente für die Bereitstellung, bereitgestellt als JSON-Zeichenfolge oder JSON-Datei. Die JSON-Zeichenfolge sollte das folgende Format haben: 

  ```
  { \
    "componentName": { \ 
      "MERGE": {"config-key": "config-value"}, \
      "RESET": ["path/to/reset/"] \
    } \
  }
  ```

  `MERGE`und `RESET` unterscheiden zwischen Groß- und Kleinschreibung und müssen in Großbuchstaben geschrieben werden.
+ `--groupId`,`-g`. Die Zielgruppe für den Einsatz.
+ `--merge`,`-m`. Der Name und die Version der Zielkomponente, die Sie hinzufügen oder aktualisieren möchten. Sie müssen die Komponenteninformationen im folgenden Format angeben`<component>=<version>`. Verwenden Sie für jede weitere Komponente, die Sie angeben möchten, ein separates Argument. Verwenden Sie bei Bedarf das `--runWith` Argument, um die `posixUser``posixGroup`, und `windowsUser` Informationen zum Ausführen der Komponente bereitzustellen.
+ `--runWith`. Die `posixUser``posixGroup`, und `windowsUser` Informationen zum Ausführen einer generischen Komponente oder einer Lambda-Komponente. Sie müssen diese Informationen im Format `<component>:{posixUser|windowsUser}=<user>[:<=posixGroup>]` angeben. Sie könnten beispielsweise **HelloWorld:posixUser=ggc\$1user:ggc\$1group** oder angeben**HelloWorld:windowsUser=ggc\$1user**. Verwenden Sie für jede weitere zu spezifizierende Option ein separates Argument.

  Weitere Informationen finden Sie unter [Konfigurieren Sie den Benutzer, der die Komponenten ausführt](configure-greengrass-core-v2.md#configure-component-user).
+ `--systemLimits`. Die Systemressourcenlimits, die für Prozesse generischer und nicht containerisierter Lambda-Komponenten auf dem Kerngerät gelten sollen. Sie können die maximale CPU- und RAM-Auslastung konfigurieren, die die Prozesse der einzelnen Komponenten verwenden können. Geben Sie ein serialisiertes JSON-Objekt oder einen Dateipfad zu einer JSON-Datei an. Das JSON-Objekt muss das folgende Format haben.

  ```
  {  \
    "componentName": { \ 
      "cpus": cpuTimeLimit, \
      "memory": memoryLimitInKb \
    } \
  }
  ```

  Sie können die folgenden Systemressourcenlimits für jede Komponente konfigurieren:
  + `cpus`— <a name="system-resource-limits-cpu-definition-this"></a>Die maximale Menge an CPU-Zeit, die die Prozesse dieser Komponente auf dem Kerngerät verwenden können. Die gesamte CPU-Zeit eines Core-Geräts entspricht der Anzahl der CPU-Kerne des Geräts. Auf einem Core-Gerät mit 4 CPU-Kernen können Sie diesen Wert beispielsweise auf festlegen, `2` um die Prozesse dieser Komponente auf 50 Prozent der Auslastung jedes CPU-Kerns zu beschränken. Auf einem Gerät mit einem CPU-Kern können Sie diesen Wert auf festlegen, `0.25` um die Prozesse dieser Komponente auf 25 Prozent der CPU-Auslastung zu beschränken. Wenn Sie diesen Wert auf eine Zahl festlegen, die größer als die Anzahl der CPU-Kerne ist, begrenzt die AWS IoT Greengrass Core-Software die CPU-Auslastung der Komponente nicht. 
  + `memory`— <a name="system-resource-limits-memory-definition-this"></a>Die maximale Menge an RAM (in Kilobyte), die die Prozesse dieser Komponente auf dem Kerngerät verwenden können. 

  Weitere Informationen finden Sie unter [Konfigurieren Sie die Systemressourcenlimits für Komponenten](configure-greengrass-core-v2.md#configure-component-system-resource-limits).

  Diese Funktion ist für Version 2.4.0 und höher der [Greengrass Nucleus-Komponente und Greengrass](greengrass-nucleus-component.md) CLI auf Linux-Core-Geräten verfügbar. AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten. 
+ `--remove`. Der Name der Zielkomponente, die Sie aus einer lokalen Bereitstellung entfernen möchten. Um eine Komponente zu entfernen, die aus einer Cloud-Bereitstellung zusammengeführt wurde, müssen Sie die Gruppen-ID der Ziel-Dinggruppe im folgenden Format angeben:

------
#### [ Greengrass nucleus v2.4.0 and later ]

  ```
  --remove <component-name> --groupId <group-name>
  ```

------
#### [ Earlier than v2.4.0 ]

  ```
  --remove <component-name> --groupId thinggroup/<group-name>
  ```

------
+ `--failure-handling-policy`. Definiert die Aktion, die ergriffen wird, wenn eine Bereitstellung fehlschlägt. Es gibt zwei Aktionen, die Sie angeben können:
  + `ROLLBACK` – 
  + `DO_NOTHING` – 

  Diese Funktion ist für Version 2.11.0 und höher von verfügbar. [Grüngraskern](greengrass-nucleus-component.md)

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die erzeugt wird, wenn Sie diesen Befehl ausführen.  

```
$ sudo greengrass-cli deployment create \
    --merge MyApp1=1.0.0 \
    --merge MyApp2=1.0.0 --runWith MyApp2:posixUser=ggc_user \
    --remove MyApp3 \
    --recipeDir recipes/ \ 
    --artifactDir artifacts/

Local deployment has been submitted! Deployment Id: 44d89f46-1a29-4044-ad89-5151213dfcbc
```

## abbrechen
<a name="deployment-cancel"></a>

Bricht die angegebene Bereitstellung ab.

Syntax  

```
greengrass-cli deployment cancel
    -i <deployment-id>
```

Argumente  
`-i`. Die eindeutige Kennung der Bereitstellung, die abgebrochen werden soll. Die Bereitstellungs-ID wird in der Ausgabe des `create` Befehls zurückgegeben.

Output  
+ Keine

## auflisten
<a name="deployment-list"></a>

Ruft den Status der letzten 10 lokalen Bereitstellungen ab.

**Syntax**  

```
greengrass-cli deployment list
```

**Argumente**  
Keine

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die bei der Ausführung dieses Befehls erzeugt wird. Je nach Status Ihrer Bereitstellung zeigt die Ausgabe einen der folgenden Statuswerte an:`IN_PROGRESS`,`SUCCEEDED`, oder`FAILED`.  

```
$ sudo greengrass-cli deployment list

44d89f46-1a29-4044-ad89-5151213dfcbc: SUCCEEDED
Created on: 6/27/23 11:05 AM
```

## Status
<a name="deployment-status"></a>

Rufen Sie den Status einer bestimmten Bereitstellung ab.

**Syntax**  

```
greengrass-cli deployment status -i <deployment-id>
```

**Argumente**  
`-i`. Die ID der Bereitstellung.

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die erzeugt wird, wenn Sie diesen Befehl ausführen. Je nach Status Ihrer Bereitstellung zeigt die Ausgabe einen der folgenden Statuswerte an:`IN_PROGRESS`,`SUCCEEDED`, oder`FAILED`.  

```
$ sudo greengrass-cli deployment status -i 44d89f46-1a29-4044-ad89-5151213dfcbc

44d89f46-1a29-4044-ad89-5151213dfcbc: FAILED
Created on: 6/27/23 11:05 AM
Detailed Status: <Detailed deployment status>
Deployment Error Stack: List of error codes
Deployment Error Types: List of error types
Failure Cause: Cause
```

# Protokolle
<a name="gg-cli-logs"></a>

Verwenden Sie den `logs` Befehl, um Greengrass-Protokolle auf Ihrem Kerngerät zu analysieren. 

**Unterbefehle**
+ [get](#logs-get)
+ [Stichwörter auflisten](#logs-list-keywords)
+ [list-log-files](#logs-list-log-files)

## get
<a name="logs-get"></a>

Sammeln, filtern und visualisieren Sie Greengrass-Protokolldateien. Dieser Befehl unterstützt nur Protokolldateien im JSON-Format. Sie können das [Logging-Format in der Nucleus-Konfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-logging-format) angeben.

**Syntax**  

```
greengrass-cli logs get
    [--log-dir path/to/a/log/folder]
    [--log-file path/to/a/log/file]
    [--follow true | false ]
    [--filter <filter> ]
    [--time-window <start-time>,<end-time> ]
    [--verbose ]
    [--no-color ]
    [--before <value> ]
    [--after <value> ]
    [--syslog ]
    [--max-long-queue-size <value> ]
```

**Argumente**  
+ `--log-dir`,`-ld`. Der Pfad zu dem Verzeichnis, in dem nach Protokolldateien gesucht werden soll, z. **`/greengrass/v2`/logs** B. Nicht mit verwenden`--syslog`. Verwenden Sie für jedes weitere Verzeichnis, das Sie angeben möchten, ein separates Argument. Sie müssen mindestens einen von `--log-dir` oder verwenden`--log-file`. Sie können auch beide Argumente in einem einzigen Befehl verwenden. 
+ `--log-file`,`-lf`. Die Pfade zu den Protokollverzeichnissen, die Sie verwenden möchten. Verwenden Sie für jedes weitere Verzeichnis, das Sie angeben möchten, ein separates Argument. Sie müssen mindestens einen von `--log-dir` oder verwenden`--log-file`. Sie können auch beide Argumente in einem einzigen Befehl verwenden.
+ `--follow`,`-fol`. Zeigt Protokollaktualisierungen an, sobald sie auftreten. Greengrass CLI läuft weiter und liest aus den angegebenen Protokollen. Wenn Sie ein Zeitfenster angeben, stoppt Greengrass CLI die Überwachung der Protokolle, nachdem alle Zeitfenster abgelaufen sind.
+ `--filter`,`-f`. Das Schlüsselwort, die regulären Ausdrücke oder das Schlüssel-Wert-Paar, das als Filter verwendet werden soll. Geben Sie diesen Wert als Zeichenfolge, als regulären Ausdruck oder als Schlüssel-Wert-Paar an. Verwenden Sie für jeden weiteren Filter, den Sie angeben möchten, ein separates Argument. 

  Bei der Auswertung werden mehrere Filter, die in einem einzigen Argument angegeben sind, durch OR-Operatoren getrennt, und in zusätzlichen Argumenten angegebene Filter werden mit AND-Operatoren kombiniert. Wenn Ihr Befehl beispielsweise beinhaltet`--filter "installed" --filter "name=alpha,name=beta"`, filtert und zeigt Greengrass CLI Protokollnachrichten an, die sowohl das Schlüsselwort `installed` als auch einen `name` Schlüssel mit den Werten `alpha` oder `beta` enthalten.
+ `--time-window`,`-t`. Das Zeitfenster, für das Protokollinformationen angezeigt werden sollen. Sie können sowohl exakte Zeitstempel als auch relative Offsets verwenden. Sie müssen diese Informationen im folgenden Format angeben. `<begin-time>,<end-time>` Wenn Sie weder die Startzeit noch die Endzeit angeben, wird als Wert für diese Option standardmäßig das aktuelle Systemdatum und die aktuelle Systemzeit verwendet. Verwenden Sie für jedes weitere Zeitfenster, das Sie angeben möchten, ein separates Argument. 

  Greengrass CLI unterstützt die folgenden Formate für Zeitstempel:
  + `yyyy-MM-DD`, zum Beispiel. `2020-06-30` Die Uhrzeit ist standardmäßig 00:00:00, wenn Sie dieses Format verwenden.

    `yyyyMMDD`, zum Beispiel. `20200630` Die Uhrzeit ist standardmäßig 00:00:00, wenn Sie dieses Format verwenden.

    `HH:mm:ss`, zum Beispiel. `15:30:45` Wenn Sie dieses Format verwenden, entspricht das Datum standardmäßig dem aktuellen Systemdatum.

    `HH:mm:ssSSS`, zum Beispiel. `15:30:45` Das Datum ist standardmäßig das aktuelle Systemdatum, wenn Sie dieses Format verwenden.

    `YYYY-MM-DD'T'HH:mm:ss'Z'`, zum Beispiel. `2020-06-30T15:30:45Z`

    `YYYY-MM-DD'T'HH:mm:ss`, zum Beispiel`2020-06-30T15:30:45`. 

    `yyyy-MM-dd'T'HH:mm:ss.SSS`, zum Beispiel`2020-06-30T15:30:45.250`.

  Relative Offsets geben einen Zeitraum an, der von der aktuellen Systemzeit abweicht. Greengrass CLI unterstützt das folgende Format für relative Offsets:. `+|-[<value>h|hr|hours][valuem|min|minutes][value]s|sec|seconds` 

  Zum Beispiel das folgende Argument zur Angabe eines Zeitfensters zwischen 1 Stunde und 2 Stunden 15 Minuten vor der aktuellen Uhrzeit. `--time-window -2h15min,-1hr`
+ `--verbose`. Zeigt alle Felder aus den Protokollnachrichten an. Nicht mit verwenden`--syslog`.
+ `--no-color`,`-nc`. Entfernen Sie die Farbcodierung. Die Standardfarbcodierung für Protokollnachrichten verwendet fett gedruckten roten Text. Unterstützt nur UNIX-ähnliche Terminals, da ANSI-Escape-Sequenzen verwendet werden.
+ `--before``-b`,. Die Anzahl der Zeilen, die vor einem übereinstimmenden Protokolleintrag angezeigt werden sollen. Standard = 0.
+ `--after`,`-a`. Die Anzahl der Zeilen, die nach einem übereinstimmenden Protokolleintrag angezeigt werden sollen. Standard = 0.
+ `--syslog`. Verarbeitet alle Protokolldateien mit dem Syslog-Protokoll, das von definiert ist. RFC3164 Nicht zusammen mit `--log-dir` und verwenden. `--verbose` Das Syslog-Protokoll verwendet das folgende Format:. `"<$Priority>$Timestamp $Host $Logger ($Class): $Message"` Wenn Sie keine Protokolldatei angeben, liest Greengrass CLI Protokollnachrichten von den folgenden Speicherorten:`/var/log/messages`,`/var/log/syslog`, oder der`/var/log/system.log`. 

  AWS IoT Greengrass unterstützt diese Funktion derzeit nicht auf Windows Core-Geräten. 
+ `--max-log-queue-size`,`-m`. Die maximale Anzahl von Protokolleinträgen, die dem Speicher zugewiesen werden sollen. Verwenden Sie diese Option, um die Speichernutzung zu optimieren. Die Standardeinstellung ist 100.

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die erzeugt wird, wenn Sie diesen Befehl ausführen.  

```
$ sudo greengrass-cli logs get --verbose \
    --log-file /greengrass/v2/logs/greengrass.log \
    --filter deployment,serviceName=DeploymentService \
    --filter level=INFO \
    --time-window 2020-12-08T01:11:17,2020-12-08T01:11:22

2020-12-08T01:11:17.615Z [INFO] (pool-2-thread-14) com.aws.greengrass.deployment.DeploymentService: Current deployment finished. {DeploymentId=44d89f46-1a29-4044-ad89-5151213dfcbc, serviceName=DeploymentService, currentState=RUNNING}
2020-12-08T01:11:17.675Z [INFO] (pool-2-thread-14) com.aws.greengrass.deployment.IotJobsHelper: Updating status of persisted deployment. {Status=SUCCEEDED, StatusDetails={detailed-deployment-status=SUCCESSFUL}, ThingName=MyThing, JobId=22d89f46-1a29-4044-ad89-5151213dfcbc
```

## Stichwörter auflisten
<a name="logs-list-keywords"></a>

Zeigt vorgeschlagene Stichwörter an, die Sie zum Filtern von Protokolldateien verwenden können.

**Syntax**  

```
greengrass-cli logs list-keywords [arguments]
```

**Argumente**  
Keine

**Ausgabe**  
Die folgenden Beispiele zeigen die Ausgabe, die bei der Ausführung dieses Befehls erzeugt wird.  

```
$ sudo greengrass-cli logs list-keywords

Here is a list of suggested keywords for Greengrass log:
level=$str
thread=$str
loggerName=$str
eventType=$str
serviceName=$str
error=$str
```

```
$ sudo greengrass-cli logs list-keywords --syslog

Here is a list of suggested keywords for syslog:
priority=$int
host=$str
logger=$str
class=$str
```

## list-log-files
<a name="logs-list-log-files"></a>

Zeigt Protokolldateien an, die sich in einem angegebenen Verzeichnis befinden.

**Syntax**  

```
greengrass-cli logs list-log-files [arguments]
```

**Argumente**  
`--log-dir`,`-ld`. Der Pfad zu dem Verzeichnis, in dem nach Protokolldateien gesucht werden soll. 

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die bei der Ausführung dieses Befehls erzeugt wird.  

```
$ sudo greengrass-cli logs list-log-files -ld /greengrass/v2/logs/

/greengrass/v2/logs/aws.greengrass.Nucleus.log
/greengrass/v2/logs/main.log
/greengrass/v2/logs/greengrass.log
Total 3 files found.
```

# get-debug-password
<a name="gg-cli-get-debug-password"></a>

Verwenden Sie den `get-debug-password` Befehl, um ein zufällig generiertes Passwort für die [lokale Debug-Konsolenkomponente () `aws.greengrass.LocalDebugConsole` auszugeben](local-debug-console-component.md). Das Passwort läuft 8 Stunden nach seiner Generierung ab.

**Syntax**  

```
greengrass-cli get-debug-password
```

**Argumente**  
Keine

**Ausgabe**  
Das folgende Beispiel zeigt die Ausgabe, die bei der Ausführung dieses Befehls erzeugt wird.  

```
$ sudo greengrass-cli get-debug-password

Username: debug
Password: bEDp3MOHdj8ou2w5de_sCBI2XAaguy3a8XxREXAMPLE
Password expires at: 2021-04-01T17:01:43.921999931-07:00
The local debug console is configured to use TLS security. The certificate is self-signed so you will need to bypass your web browser's security warnings to open the console.
Before you bypass the security warning, verify that the certificate fingerprint matches the following fingerprints.
SHA-256: 15 0B 2C E2 54 8B 22 DE 08 46 54 8A B1 2B 25 DE FB 02 7D 01 4E 4A 56 67 96 DA A6 CC B1 D2 C4 1B
SHA-1: BC 3E 16 04 D3 80 70 DA E0 47 25 F9 90 FA D6 02 80 3E B5 C1
```