

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.

# Konfiguration der Befehlsvervollständigung in AWS CLI
<a name="cli-configure-completion"></a>

**Das AWS Command Line Interface (AWS CLI) beinhaltet eine Bash-kompatible Funktion zur Befehlsvervollständigung, mit der Sie die Tabulatortaste verwenden können, um einen teilweise eingegebenen Befehl abzuschließen.** Auf den meisten Systemen müssen Sie dies manuell konfigurieren.

Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie stattdessen unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).

**Topics**
+ [Funktionsweise](#cli-command-completion-about)
+ [Konfigurieren der Befehlsvervollständigung unter Linux oder macOS](#cli-command-completion-linux)
+ [Konfigurieren der Befehlsvervollständigung unter Windows](#cli-command-completion-windows)

## Funktionsweise
<a name="cli-command-completion-about"></a>

Wenn Sie einen Befehl, einen Parameter oder eine Option teilweise eingeben, wird der Befehl vom Befehlsvervollständigungs-Feature entweder automatisch vervollständigt oder von dieser eine Liste mit vorgeschlagenen Befehlen angezeigt. Um die Befehlsvervollständigung aufzufordern, geben Sie einen Befehl teilweise ein und drücken dann die Vervollständigungstaste, was normalerweise *Tab* in den meisten Shells der Fall ist.

Die folgenden Beispiele zeigen verschiedene Möglichkeiten, wie Sie die Befehlsvervollständigung nutzen können:
+ Geben Sie einen Befehl teilweise ein und drücken Sie*Tab*, um eine vorgeschlagene Befehlsliste anzuzeigen.

  ```
  $ aws dynamodb dTAB
  delete-backup                        describe-global-table
  delete-item                          describe-global-table-settings
  delete-table                         describe-limits
  describe-backup                      describe-table
  describe-continuous-backups          describe-table-replica-auto-scaling
  describe-contributor-insights        describe-time-to-live
  describe-endpoints
  ```
+ Geben Sie einen Parameter teilweise ein und drücken Sie*Tab*, um eine vorgeschlagene Parameterliste anzuzeigen.

  ```
  $ aws dynamodb delete-table --TAB
  --ca-bundle              --endpoint-url           --profile              
  --cli-connect-timeout    --generate-cli-skeleton  --query                
  --cli-input-json         --no-paginate            --region               
  --cli-read-timeout       --no-sign-request        --table-name           
  --color                  --no-verify-ssl          --version              
  --debug                  --output
  ```
+ Geben Sie einen Parameter ein und drücken Sie*Tab*, um eine vorgeschlagene Liste von Ressourcenwerten anzuzeigen. Diese Funktion ist nur in AWS CLI Version 2 verfügbar.

  ```
  $ aws dynamodb delete-table --table-name TAB
  Table 1                  Table 2                  Table 3
  ```

## Konfigurieren der Befehlsvervollständigung unter Linux oder macOS
<a name="cli-command-completion-linux"></a>

Um die Befehlsvervollständigung unter Linux oder macOS zu konfigurieren, müssen Sie den Namen der verwendeten Shell und den Speicherort des `aws_completer`-Skripts kennen.

**Anmerkung**  
Auf Amazon-EC2-Instances, die Amazon Linux ausführen, ist die Befehlsvervollständigung automatisch konfiguriert und standardmäßig aktiviert.

**Topics**
+ [Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet](#cli-command-completion-path)
+ [Aktivieren der Befehlsvervollständigung](#cli-command-completion-enable)
+ [Verifizieren der Befehlsvervollständigung](#cli-command-completion-test)

### Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet
<a name="cli-command-completion-path"></a>

Damit der AWS Completer erfolgreich funktioniert, `aws_completer` muss er sich im Pfad Ihrer Shell befinden. Der `which`-Befehl kann überprüfen, ob sich die Vervollständigung in Ihrem Pfad befindet.

```
$ which aws_completer
/usr/local/bin/aws_completer
```

Wenn der Befehl die Vervollständigung nicht finden kann, führen Sie die folgenden Schritte aus, um den Ordner der Vervollständigung zu Ihrem Pfad hinzuzufügen.

#### Schritt 1: Suchen Sie den Completer AWS
<a name="cli-command-completion-locate"></a>

 Der Standort des AWS Completers kann je nach verwendeter Installationsmethode variieren. 
+ **Paketmanager** — Programme wie`pip`, `yum``brew`, und installieren den AWS Completer (oder einen Symlink dazu) `apt-get` normalerweise an einem Standardpfad. 
  + Wenn Sie `pip` **ohne** den Parameter `--user` verwendet haben, ist der Standardpfad `/usr/local/bin/aws_completer`.
  + Wenn Sie `pip` **ohne** den Parameter `--user` verwendet haben, ist der Standardpfad `/home/username/.local/bin/aws_completer`.
+ **Gebündeltes Installationsprogramm** – Wenn Sie das mitgelieferte Installationsprogramm verwendet haben, ist der Standardpfad `/usr/local/bin/aws_completer`.

Wenn alles andere fehlschlägt, können Sie den `find` Befehl verwenden, um Ihr Dateisystem nach dem AWS Completer zu durchsuchen. 

```
$ find / -name aws_completer
/usr/local/bin/aws_completer
```

#### Schritt 2: Identifizieren Ihrer Shell
<a name="cli-command-completion-shell"></a>

Um zu ermitteln, welche Shell Sie verwenden, können Sie einen der folgenden Befehle verwenden.
+ **echo \$1SHELL** – Zeigt den Programmdateinamen der Shell an. Dieser wird in der Regel für die verwendete Shell korrekt sein, sofern Sie keine andere Shell nach dem Anmelden gestartet haben.

  ```
  $ echo $SHELL
  /bin/bash
  ```
+ **ps** – Zeigt die für den aktuellen Benutzer ausgeführten Prozesse an. Einer von ihnen ist die Shell.

  ```
  $ ps
    PID TTY          TIME CMD
   2148 pts/1    00:00:00 bash
   8756 pts/1    00:00:00 ps
  ```

#### Schritt 3: Fügen Sie die Vervollständigung zu Ihrem Pfad hinzu
<a name="cli-command-completion-path-add"></a>

1. Suchen Sie das Profilskript für die Shell in Ihrem Benutzerordner.

   ```
   $ ls -a ~/
   .  ..  .bash_logout  .bash_profile  .bashrc  Desktop  Documents  Downloads
   ```
   + **Bash** – `.bash_profile`, `.profile` oder `.bash_login`
   + **Zsh**– `.zshrc`
   + **Tcsh**– `.tcshrc`, `.cshrc` oder `.login`

1. Fügen Sie einen Exportbefehl an das Ende Ihres Profilskripts hinzu und orientieren Sie sich dabei an folgendem Beispiel. Ersetzen Sie `/usr/local/bin/` durch den Ordner, den Sie im vorherigen Abschnitt entdeckt haben.

   ```
   export PATH=/usr/local/bin/:$PATH
   ```

1. Laden Sie das Profil erneut in die aktuelle Sitzung, damit die Änderungen wirksam werden. Ersetzen Sie `.bash_profile` durch den Namen des Shell-Skripts, das Sie im ersten Abschnitt entdeckt haben.

   ```
   $ source ~/.bash_profile
   ```

### Aktivieren der Befehlsvervollständigung
<a name="cli-command-completion-enable"></a>

Nachdem Sie bestätigt haben, dass sich die Vervollständigung in Ihrem Pfad befindet, aktivieren Sie die Befehlsvervollständigung, indem Sie den entsprechenden Befehl für die von Ihnen verwendete Shell ausführen. Sie können den Befehl des Profils Ihrer Shell hinzufügen, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen. Ersetzen Sie in jedem Befehl den Pfad durch den */usr/local/bin/* Pfad, den Sie auf Ihrem System unter finden. [Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet](#cli-command-completion-path)
+ **`bash`** – Verwenden Sie den integrierten Befehl `complete`.

  ```
  $ complete -C '/usr/local/bin/aws_completer' aws
  ```

  Fügen Sie den vorherigen Befehl `~/.bashrc` hinzu, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen. Ihr `~/.bash_profile` sollte `~/.bashrc` bereitstellen, um sicherzustellen, dass der Befehl auch in Anmelde-Shells ausgeführt wird.
+  **`zsh`** – Um die Befehlsvervollständigung auszuführen, müssen Sie `bashcompinit` ausführen, indem Sie die folgende Autoload-Zeile am Ende Ihres `~/.zshrc`-Profilskripts hinzufügen.

  ```
  $ autoload bashcompinit && bashcompinit
  $ autoload -Uz compinit && compinit
  ```

  Um die Befehlsvervollständigung zu aktivieren, verwenden Sie den integrierten Befehl `complete`.

  ```
  $ complete -C '/usr/local/bin/aws_completer' aws
  ```

  Fügen Sie die vorherigen Befehle `~/.zshrc` hinzu, sodass sie immer ausgeführt werden, wenn Sie eine neue Shell öffnen.
+  **`tcsh`** – Die Vervollständigung für `tcsh` erwartet einen Worttyp und ein Muster, um das Vervollständigungsverhalten zu definieren. 

  ```
  > complete aws 'p/*/`aws_completer`/'
  ```

  Fügen Sie den vorherigen Befehl `~/.tcshrc` hinzu, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen.

Nachdem Sie die Befehlsvervollständigung aktiviert haben, funktioniert [Verifizieren der Befehlsvervollständigung](#cli-command-completion-test).

### Verifizieren der Befehlsvervollständigung
<a name="cli-command-completion-test"></a>

Nachdem Sie die Befehlsvervollständigung aktiviert haben, laden Sie Ihre Shell neu, geben Sie einen Teilbefehl ein und drücken Sie die **Tab**-Taste, um die verfügbaren Befehle anzuzeigen.

```
$ aws sTAB
s3              ses             sqs             sts             swf
s3api           sns             storagegateway  support
```

## Konfigurieren der Befehlsvervollständigung unter Windows
<a name="cli-command-completion-windows"></a>

**Anmerkung**  
*Informationen dazu, wie PowerShell mit ihrer Vervollständigung umgegangen wird, einschließlich ihrer verschiedenen Vervollständigungsschlüssel, finden Sie unter [about\$1Tab\$1Expansion](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_tab_expansion) in den Microsoft Docs. PowerShell*

Um die Befehlsvervollständigung für PowerShell unter Windows zu aktivieren, führen Sie die folgenden Schritte unter aus. PowerShell

1. Öffnen Sie Ihr `$PROFILE` mit dem folgenden Befehl.

   ```
   PS C:\> Notepad $PROFILE
   ```

   Wenn Sie kein `$PROFILE` haben, erstellen Sie mit dem folgenden Befehl ein Benutzerprofil.

   ```
   PS C:\> if (!(Test-Path -Path $PROFILE ))
   { New-Item -Type File -Path $PROFILE -Force }
   ```

   Weitere Informationen zu PowerShell Profilen finden Sie unter [So verwenden Sie Profile in Windows PowerShell ISE](https://docs.microsoft.com/en-us/powershell/scripting/windows-powershell/ise/how-to-use-profiles-in-windows-powershell-ise) auf der *Microsoft Docs-Website*.

1. Um die Befehlsvervollständigung zu aktivieren, fügen Sie dem Profil den folgenden Codeblock hinzu, speichern und schließen Sie die Datei.

   ```
   Register-ArgumentCompleter -Native -CommandName aws -ScriptBlock {
       param($commandName, $wordToComplete, $cursorPosition)
           $env:COMP_LINE=$wordToComplete
           if ($env:COMP_LINE.Length -lt $cursorPosition){
               $env:COMP_LINE=$env:COMP_LINE + " "
           }
           $env:COMP_POINT=$cursorPosition
           aws_completer.exe | ForEach-Object {
               [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
           }
           Remove-Item Env:\COMP_LINE     
           Remove-Item Env:\COMP_POINT  
   }
   ```

1. Nachdem Sie die Befehlsvervollständigung aktiviert haben, laden Sie Ihre Shell neu, geben Sie einen Teilbefehl ein und drücken Sie die **Tab**-Taste, um die verfügbaren Befehle zu durchlaufen.

   ```
   $ aws sTab
   ```

   ```
   $ aws s3
   ```

   Um alle verfügbaren Befehle zu sehen, die zur Vervollständigung verfügbar sind, geben Sie einen Teil eines Befehls ein und drücken Sie **Strg** \$1 **Leerzeichen**.

   ```
   $ aws sCtrl + Space
   s3              ses             sqs             sts             swf
   s3api           sns             storagegateway  support
   ```